# -*- coding: utf-8 -*-
from gi.repository import GObject
COMPONENTLAYER_COUNT = r"""9"""
COORD_TYPE_COUNT = r"""2"""


class Cache:
    """"""
    NONE = 0
    PARENT = 1
    CHILDREN = 2
    NAME = 4
    DESCRIPTION = 8
    STATES = 16
    ROLE = 32
    INTERFACES = 64
    ATTRIBUTES = 128
    ALL = 1073741823
    DEFAULT = 127
    UNDEFINED = 1073741824


class CollectionMatchType:
    """Enumeration used by #AtspiMatchRule to specify
how to interpret #AtspiAccessible objects."""
    INVALID = 0
    ALL = 1
    ANY = 2
    NONE = 3
    EMPTY = 4
    LAST_DEFINED = 5


class CollectionSortOrder:
    """Enumeration used by interface #AtspiCollection to specify
the way #AtspiAccesible objects should be sorted."""
    INVALID = 0
    CANONICAL = 1
    FLOW = 2
    TAB = 3
    REVERSE_CANONICAL = 4
    REVERSE_FLOW = 5
    REVERSE_TAB = 6
    LAST_DEFINED = 7


class CollectionTreeTraversalType:
    """Enumeration used by interface #AtspiCollection to specify
restrictions on #AtspiAccesible objects to be traversed."""
    RESTRICT_CHILDREN = 0
    RESTRICT_SIBLING = 1
    INORDER = 2
    LAST_DEFINED = 3


class ComponentLayer:
    """The #AtspiComponentLayer of an #AtspiComponent instance indicates its
relative stacking order with respect to the onscreen visual representation
of the UI. #AtspiComponentLayer, in combination with #AtspiComponent bounds
information, can be used to compute the visibility of all or part of a
component.  This is important in programmatic determination of
region-of-interest for magnification, and in
flat screen review models of the screen, as well as
for other uses. Objects residing in two of the #AtspiComponentLayer
categories support further z-ordering information, with respect to their
peers in the same layer: namely, @ATSPI_LAYER_WINDOW and
@ATSPI_LAYER_MDI.  Relative stacking order for other objects within the
same layer is not available; the recommended heuristic is
first child paints first. In other words, assume that the
first siblings in the child list are subject to being overpainted by later
siblings if their bounds intersect. The order of layers, from bottom to top,
 is: @ATSPI_LAYER_BACKGROUND, @ATSPI_LAYER_WINDOW, @ATSPI_LAYER_MDI,
@ATSPI_LAYER_CANVAS, @ATSPI_LAYER_WIDGET, @ATSPI_LAYER_POPUP, and
@ATSPI_LAYER_OVERLAY."""
    INVALID = 0
    BACKGROUND = 1
    CANVAS = 2
    WIDGET = 3
    MDI = 4
    POPUP = 5
    OVERLAY = 6
    WINDOW = 7
    LAST_DEFINED = 8


class CoordType:
    """Enumeration used by #AtspiComponent, #AtspiImage, and #AtspiText interfaces
to specify whether coordinates are relative to the window or the screen."""
    SCREEN = 0
    WINDOW = 1
DBUS_INTERFACE_ACCESSIBLE = r"""org.a11y.atspi.Accessible"""
DBUS_INTERFACE_ACTION = r"""org.a11y.atspi.Action"""
DBUS_INTERFACE_APPLICATION = r"""org.a11y.atspi.Application"""
DBUS_INTERFACE_CACHE = r"""org.a11y.atspi.Cache"""
DBUS_INTERFACE_COLLECTION = r"""org.a11y.atspi.Collection"""
DBUS_INTERFACE_COMPONENT = r"""org.a11y.atspi.Component"""
DBUS_INTERFACE_DEC = r"""org.a11y.atspi.DeviceEventController"""
DBUS_INTERFACE_DEVICE_EVENT_LISTENER = r"""org.a11y.atspi.DeviceEventListener"""
DBUS_INTERFACE_DOCUMENT = r"""org.a11y.atspi.Document"""
DBUS_INTERFACE_EDITABLE_TEXT = r"""org.a11y.atspi.EditableText"""
DBUS_INTERFACE_EVENT_KEYBOARD = r"""org.a11y.atspi.Event.Keyboard"""
DBUS_INTERFACE_EVENT_MOUSE = r"""org.a11y.atspi.Event.Mouse"""
DBUS_INTERFACE_EVENT_OBJECT = r"""org.a11y.atspi.Event.Object"""
DBUS_INTERFACE_HYPERLINK = r"""org.a11y.atspi.Hyperlink"""
DBUS_INTERFACE_HYPERTEXT = r"""org.a11y.atspi.Hypertext"""
DBUS_INTERFACE_IMAGE = r"""org.a11y.atspi.Image"""
DBUS_INTERFACE_REGISTRY = r"""org.a11y.atspi.Registry"""
DBUS_INTERFACE_SELECTION = r"""org.a11y.atspi.Selection"""
DBUS_INTERFACE_SOCKET = r"""org.a11y.atspi.Socket"""
DBUS_INTERFACE_TABLE = r"""org.a11y.atspi.Table"""
DBUS_INTERFACE_TABLE_CELL = r"""org.a11y.atspi.TableCell"""
DBUS_INTERFACE_TEXT = r"""org.a11y.atspi.Text"""
DBUS_INTERFACE_VALUE = r"""org.a11y.atspi.Value"""
DBUS_NAME_REGISTRY = r"""org.a11y.atspi.Registry"""
DBUS_PATH_DEC = r"""/org/a11y/atspi/registry/deviceeventcontroller"""
DBUS_PATH_NULL = r"""/org/a11y/atspi/null"""
DBUS_PATH_REGISTRY = r"""/org/a11y/atspi/registry"""
DBUS_PATH_ROOT = r"""/org/a11y/atspi/accessible/root"""
EVENTTYPE_COUNT = r"""4"""


class EventType:
    """Enumeration used to specify the event types of interest to an
#AtspiEventListener, or
to identify the type of an event for which notification has been sent."""
    KEY_PRESSED_EVENT = 0
    KEY_RELEASED_EVENT = 1
    BUTTON_PRESSED_EVENT = 2
    BUTTON_RELEASED_EVENT = 3
KEYEVENTTYPE_COUNT = r"""2"""
KEYSYNTHTYPE_COUNT = r"""5"""


class KeyEventType:
    """Deprecated. Should not be used."""
    PRESSED = 0
    RELEASED = 1


class KeyListenerSyncType:
    """Specifies the type of a key listener event.
The values above can and should be bitwise-'OR'-ed
together, observing the compatibility limitations specified in the description of
each value.  For instance, #ATSPI_KEYLISTENER_ALL_WINDOWS | #ATSPI_KEYLISTENER_CANCONSUME is
a commonly used combination which gives the AT complete control over the delivery of matching
events.  However, such filters should be used sparingly as they may have a negative impact on
system performance."""
    NOSYNC = 0
    SYNCHRONOUS = 1
    CANCONSUME = 2
    ALL_WINDOWS = 4


class KeySynthType:
    """Enumeration used when synthesizing keyboard input via
#atspi_generate_keyboard_event."""
    PRESS = 0
    RELEASE = 1
    PRESSRELEASE = 2
    SYM = 3
    STRING = 4


class LocaleType:
    """Used by interfaces #AtspiText and #AtspiDocument, this
enumeration corresponds to the POSIX 'setlocale' enum values."""
    MESSAGES = 0
    COLLATE = 1
    CTYPE = 2
    MONETARY = 3
    NUMERIC = 4
    TIME = 5
MATCHTYPES_COUNT = r"""6"""
MODIFIERTYPE_COUNT = r"""8"""


class ModifierType:
    """"""
    SHIFT = 0
    SHIFTLOCK = 1
    CONTROL = 2
    ALT = 3
    META = 4
    META2 = 5
    META3 = 6
    NUMLOCK = 14
RELATIONTYPE_COUNT = r"""24"""
ROLE_COUNT = r"""126"""


class RelationType:
    """#AtspiRelationType specifies a relationship between objects
(possibly one-to-many
or many-to-one) outside of the normal parent/child hierarchical
relationship. It allows better semantic       identification of how objects
are associated with one another.       For instance the
@ATSPI_RELATION_LABELLED_BY
relationship may be used to identify labelling information       that should
accompany the accessible name property when presenting an object's content or
identity       to the end user.  Similarly,
@ATSPI_RELATION_CONTROLLER_FOR can be used
to further specify the context in which a valuator is useful, and/or the
other UI components which are directly effected by user interactions with
the valuator. Common examples include association of scrollbars with the
viewport or panel which they control.


Enumeration used to specify
the type of relation encapsulated in an #AtspiRelation object."""
    NULL = 0
    LABEL_FOR = 1
    LABELLED_BY = 2
    CONTROLLER_FOR = 3
    CONTROLLED_BY = 4
    MEMBER_OF = 5
    TOOLTIP_FOR = 6
    NODE_CHILD_OF = 7
    NODE_PARENT_OF = 8
    EXTENDED = 9
    FLOWS_TO = 10
    FLOWS_FROM = 11
    SUBWINDOW_OF = 12
    EMBEDS = 13
    EMBEDDED_BY = 14
    POPUP_FOR = 15
    PARENT_WINDOW_OF = 16
    DESCRIPTION_FOR = 17
    DESCRIBED_BY = 18
    DETAILS = 19
    DETAILS_FOR = 20
    ERROR_MESSAGE = 21
    ERROR_FOR = 22
    LAST_DEFINED = 23


class Role:
    """Enumeration used by interface #AtspiAccessible to specify the role
of an #AtspiAccessible object."""
    INVALID = 0
    ACCELERATOR_LABEL = 1
    ALERT = 2
    ANIMATION = 3
    ARROW = 4
    CALENDAR = 5
    CANVAS = 6
    CHECK_BOX = 7
    CHECK_MENU_ITEM = 8
    COLOR_CHOOSER = 9
    COLUMN_HEADER = 10
    COMBO_BOX = 11
    DATE_EDITOR = 12
    DESKTOP_ICON = 13
    DESKTOP_FRAME = 14
    DIAL = 15
    DIALOG = 16
    DIRECTORY_PANE = 17
    DRAWING_AREA = 18
    FILE_CHOOSER = 19
    FILLER = 20
    FOCUS_TRAVERSABLE = 21
    FONT_CHOOSER = 22
    FRAME = 23
    GLASS_PANE = 24
    HTML_CONTAINER = 25
    ICON = 26
    IMAGE = 27
    INTERNAL_FRAME = 28
    LABEL = 29
    LAYERED_PANE = 30
    LIST = 31
    LIST_ITEM = 32
    MENU = 33
    MENU_BAR = 34
    MENU_ITEM = 35
    OPTION_PANE = 36
    PAGE_TAB = 37
    PAGE_TAB_LIST = 38
    PANEL = 39
    PASSWORD_TEXT = 40
    POPUP_MENU = 41
    PROGRESS_BAR = 42
    PUSH_BUTTON = 43
    RADIO_BUTTON = 44
    RADIO_MENU_ITEM = 45
    ROOT_PANE = 46
    ROW_HEADER = 47
    SCROLL_BAR = 48
    SCROLL_PANE = 49
    SEPARATOR = 50
    SLIDER = 51
    SPIN_BUTTON = 52
    SPLIT_PANE = 53
    STATUS_BAR = 54
    TABLE = 55
    TABLE_CELL = 56
    TABLE_COLUMN_HEADER = 57
    TABLE_ROW_HEADER = 58
    TEAROFF_MENU_ITEM = 59
    TERMINAL = 60
    TEXT = 61
    TOGGLE_BUTTON = 62
    TOOL_BAR = 63
    TOOL_TIP = 64
    TREE = 65
    TREE_TABLE = 66
    UNKNOWN = 67
    VIEWPORT = 68
    WINDOW = 69
    EXTENDED = 70
    HEADER = 71
    FOOTER = 72
    PARAGRAPH = 73
    RULER = 74
    APPLICATION = 75
    AUTOCOMPLETE = 76
    EDITBAR = 77
    EMBEDDED = 78
    ENTRY = 79
    CHART = 80
    CAPTION = 81
    DOCUMENT_FRAME = 82
    HEADING = 83
    PAGE = 84
    SECTION = 85
    REDUNDANT_OBJECT = 86
    FORM = 87
    LINK = 88
    INPUT_METHOD_WINDOW = 89
    TABLE_ROW = 90
    TREE_ITEM = 91
    DOCUMENT_SPREADSHEET = 92
    DOCUMENT_PRESENTATION = 93
    DOCUMENT_TEXT = 94
    DOCUMENT_WEB = 95
    DOCUMENT_EMAIL = 96
    COMMENT = 97
    LIST_BOX = 98
    GROUPING = 99
    IMAGE_MAP = 100
    NOTIFICATION = 101
    INFO_BAR = 102
    LEVEL_BAR = 103
    TITLE_BAR = 104
    BLOCK_QUOTE = 105
    AUDIO = 106
    VIDEO = 107
    DEFINITION = 108
    ARTICLE = 109
    LANDMARK = 110
    LOG = 111
    MARQUEE = 112
    MATH = 113
    RATING = 114
    TIMER = 115
    STATIC = 116
    MATH_FRACTION = 117
    MATH_ROOT = 118
    SUBSCRIPT = 119
    SUPERSCRIPT = 120
    DESCRIPTION_LIST = 121
    DESCRIPTION_TERM = 122
    DESCRIPTION_VALUE = 123
    FOOTNOTE = 124
    LAST_DEFINED = 125
SORTORDER_COUNT = r"""8"""
STATETYPE_COUNT = r"""42"""


class StateType:
    """Enumeration used by various interfaces indicating every possible state
an #AtspiAccesible object can assume."""
    INVALID = 0
    ACTIVE = 1
    ARMED = 2
    BUSY = 3
    CHECKED = 4
    COLLAPSED = 5
    DEFUNCT = 6
    EDITABLE = 7
    ENABLED = 8
    EXPANDABLE = 9
    EXPANDED = 10
    FOCUSABLE = 11
    FOCUSED = 12
    HAS_TOOLTIP = 13
    HORIZONTAL = 14
    ICONIFIED = 15
    MODAL = 16
    MULTI_LINE = 17
    MULTISELECTABLE = 18
    OPAQUE = 19
    PRESSED = 20
    RESIZABLE = 21
    SELECTABLE = 22
    SELECTED = 23
    SENSITIVE = 24
    SHOWING = 25
    SINGLE_LINE = 26
    STALE = 27
    TRANSIENT = 28
    VERTICAL = 29
    VISIBLE = 30
    MANAGES_DESCENDANTS = 31
    INDETERMINATE = 32
    REQUIRED = 33
    TRUNCATED = 34
    ANIMATED = 35
    INVALID_ENTRY = 36
    SUPPORTS_AUTOCOMPLETION = 37
    SELECTABLE_TEXT = 38
    IS_DEFAULT = 39
    VISITED = 40
    CHECKABLE = 41
    HAS_POPUP = 42
    READ_ONLY = 43
    LAST_DEFINED = 44
TEXT_BOUNDARY_TYPE_COUNT = r"""7"""
TEXT_CLIP_TYPE_COUNT = r"""4"""


class TextBoundaryType:
    """Specifies the boundary conditions determining a run of text as returned from
#atspi_text_get_text_at_offset, #atspi_text_get_text_after_offset, and
#atspi_text_get_text_before_offset.

This enumerationis deprecated since 2.9.90 and should not be used. Use
AtspiTextGranularity with #atspi_text_get_string_at_offset instead."""
    CHAR = 0
    WORD_START = 1
    WORD_END = 2
    SENTENCE_START = 3
    SENTENCE_END = 4
    LINE_START = 5
    LINE_END = 6


class TextClipType:
    """Enumeration used by interface #AtspiText to indicate
how to treat characters intersecting bounding boxes."""
    NONE = 0
    MIN = 1
    MAX = 2
    BOTH = 3


class TextGranularity:
    """Text granularity types used for specifying the granularity of the region of
text we are interested in."""
    CHAR = 0
    WORD = 1
    SENTENCE = 2
    LINE = 3
    PARAGRAPH = 4

def dbus_connection_setup_with_g_main(connection=None, context=None):
    """    Sets the watch and timeout functions of a #DBusConnection
    to integrate the connection with the GLib main loop.
    Pass in #NULL for the #GMainContext unless you're
    doing something specialized.
    
    If called twice for the same context, does nothing the second
    time. If called once with context A and once with context B,
    context B replaces context A as the context monitoring the
    connection.
    @param connection: the connection
    @param context: the #GMainContext or #NULL for default context
    @type connection: DBus.Connection
    @type context: GLib.MainContext
    @returns: 
    @rtype: None
    """
    return object

def dbus_server_setup_with_g_main(server=None, context=None):
    """    Sets the watch and timeout functions of a #DBusServer
    to integrate the server with the GLib main loop.
    In most cases the context argument should be #NULL.
    
    If called twice for the same context, does nothing the second
    time. If called once with context A and once with context B,
    context B replaces context A as the context monitoring the
    connection.
    @param server: the server
    @param context: the #GMainContext or #NULL for default
    @type server: object
    @type context: GLib.MainContext
    @returns: 
    @rtype: None
    """
    return object

def deregister_device_event_listener(listener=None, filter=None):
    """    Removes a device event listener from the registry's listener queue,
               ceasing notification of events of the specified type.
    @param listener: a pointer to the #AtspiDeviceListener for which            device events are requested.
    @param filter: Unused parameter.
    @type listener: DeviceListener
    @type filter: gpointer
    @returns: %TRUE if successful, otherwise %FALSE.
    @rtype: bool
    """
    return object

def deregister_keystroke_listener(listener=None, key_set=None, modmask=None, event_types=None):
    """    Removes a keystroke event listener from the registry's listener queue,
               ceasing notification of events with modifiers matching @modmask.
    @param listener: a pointer to the #AtspiDeviceListener for which            keystroke events are requested.
    @param key_set: a pointer to the        #AtspiKeyDefinition array indicating which keystroke events are        requested, or %NULL        to indicate that all keycodes and keyvals for the specified        modifier set are to be included.
    @param modmask: the key modifier mask for which this listener is to be            'deregistered' (of type #AtspiKeyMaskType).
    @param event_types: an #AtspiKeyMaskType mask indicating which             types of key events were requested (%ATSPI_KEY_PRESSED, etc.).
    @type listener: DeviceListener
    @type modmask: KeyMaskType
    @type event_types: KeyEventMask
    @returns: %TRUE if successful, otherwise %FALSE.
    @rtype: bool
    """
    return object

def event_main():
    """    Starts/enters the main event loop for the AT-SPI services.
    
    NOTE: This method does not return control; it is exited via a call to
    #atspi_event_quit from within an event handler.
    @returns: 
    @rtype: None
    """
    return object

def event_quit():
    """    Quits the last main event loop for the AT-SPI services,
    See: #atspi_event_main
    @returns: 
    @rtype: None
    """
    return object

def exit():
    """    Disconnects from #AtspiRegistry instances and releases
    any floating resources. Call only once at exit.
    @returns: 0 if there were no leaks, otherwise other integer values.
    @rtype: int
    """
    return object

def generate_keyboard_event(keyval=None, keystring=None, synth_type=None):
    """    Synthesizes a keyboard event (as if a hardware keyboard event occurred in the
    current UI context).
    @param keyval: a #gint indicating the keycode or keysym of the key event           being synthesized.
    @param keystring: an (optional) UTF-8 string which, if           @synth_type is %ATSPI_KEY_STRING, indicates a 'composed'           keyboard input string being synthesized; this type of           keyboard event synthesis does not emulate hardware           keypresses but injects the string as though a composing           input method (such as XIM) were used.
    @param synth_type: an #AtspiKeySynthType flag indicating whether @keyval           is to be interpreted as a keysym rather than a keycode           (%ATSPI_KEY_SYM) or a string (%ATSPI_KEY_STRING), or           whether to synthesize %ATSPI_KEY_PRESS,           %ATSPI_KEY_RELEASE, or both (%ATSPI_KEY_PRESSRELEASE).
    @type keyval: long
    @type keystring: str
    @type synth_type: KeySynthType
    @returns: %TRUE if successful, otherwise %FALSE.
    @rtype: bool
    """
    return object

def generate_mouse_event(x=None, y=None, name=None):
    """    Synthesizes a mouse event at a specific screen coordinate.
    Most AT clients should use the #AccessibleAction interface when
    tempted to generate mouse events, rather than this method.
    Event names: b1p = button 1 press; b2r = button 2 release;
                 b3c = button 3 click; b2d = button 2 double-click;
                 abs = absolute motion; rel = relative motion.
    @param x: a #glong indicating the screen x coordinate of the mouse event.
    @param y: a #glong indicating the screen y coordinate of the mouse event.
    @param name: a string indicating which mouse event to be synthesized        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
    @type x: long
    @type y: long
    @type name: str
    @returns: %TRUE if successful, otherwise %FALSE.
    @rtype: bool
    """
    return object

def get_a11y_bus():
    """    
    @returns: 
    @rtype: DBus.Connection
    """
    return object

def get_desktop(i=None):
    """    Gets the virtual desktop indicated by index @i.
    NOTE: currently multiple virtual desktops are not implemented;
    as a consequence, any @i value different from 0 will not return a
    virtual desktop - instead it will return NULL.
    @param i: a #gint indicating which of the accessible desktops is to be returned.
    @type i: int
    @returns: a pointer to the @i-th virtual desktop's #AtspiAccessible representation.
    @rtype: Accessible
    """
    return object

def get_desktop_count():
    """    Gets the number of virtual desktops.
    NOTE: multiple virtual desktops are not implemented yet; as a
    consequence, this function always returns 1.
    @returns: a #gint indicating the number of active virtual desktops.
    @rtype: int
    """
    return object

def get_desktop_list():
    """    Gets the list of virtual desktops.  On return, @list will point
        to a newly-created, NULL terminated array of virtual desktop
        pointers.
        It is the responsibility of the caller to free this array when
        it is no longer needed.
    NOTE: currently multiple virtual desktops are not implemented;
    this implementation always returns a #Garray with a single
    #AtspiAccessible desktop.
    @rtype: None
    """
    return object

def init():
    """    Connects to the accessibility registry and initializes the SPI.
    @returns: 0 on success, 1 if already initialized, or an integer error code.
    @rtype: int
    """
    return object

def is_initialized():
    """    Indicates whether AT-SPI has been initialized.
    @returns: %True if initialized; %False otherwise.
    @rtype: bool
    """
    return object

def register_device_event_listener(listener=None, event_types=None, filter=None):
    """    Registers a listener for device events, for instance button events.
    @param listener: a pointer to the #AtspiDeviceListener which requests             the events.
    @param event_types: an #AtspiDeviceEventMask mask indicating which             types of key events are requested (%ATSPI_KEY_PRESSED, etc.).
    @param filter: Unused parameter.
    @type listener: DeviceListener
    @type event_types: DeviceEventMask
    @type filter: gpointer
    @returns: %TRUE if successful, otherwise %FALSE.
    @rtype: bool
    """
    return object

def register_keystroke_listener(listener=None, key_set=None, modmask=None, event_types=None, sync_type=None):
    """    Registers a listener for keystroke events, either pre-emptively for
                all windows (%ATSPI_KEYLISTENER_ALL_WINDOWS),
                non-preemptively (%ATSPI_KEYLISTENER_NOSYNC), or
                pre-emptively at the toolkit level (%ATSPI_KEYLISTENER_CANCONSUME).
                If ALL_WINDOWS or CANCONSUME are used, the event is consumed
                upon receipt if one of @listener's callbacks returns %TRUE
                (other sync_type values may be available in the future).
    @param listener: a pointer to the #AtspiDeviceListener for which             keystroke events are requested.
    @param key_set: a pointer to the        #AtspiKeyDefinition array indicating which keystroke events are        requested, or NULL        to indicate that all keycodes and keyvals for the specified        modifier set are to be included.
    @param modmask: an #AtspiKeyMaskType mask indicating which             key event modifiers must be set in combination with @keys,             events will only be reported for key events for which all             modifiers in @modmask are set.  If you wish to listen for             events with multiple modifier combinations, you must call             #atspi_register_keystroke_listener once for each             combination.
    @param event_types: an #AtspiKeyMaskType mask indicating which             types of key events are requested (%ATSPI_KEY_PRESSED etc.).
    @param sync_type: an #AtspiKeyListenerSyncType parameter indicating             the behavior of the notification/listener transaction.
    @type listener: DeviceListener
    @type modmask: KeyMaskType
    @type event_types: KeyEventMask
    @type sync_type: KeyListenerSyncType
    @returns: %TRUE if successful, otherwise %FALSE.
    @rtype: bool
    """
    return object

def role_get_name(role=None):
    """    Gets a localizable string that indicates the name of an #AtspiRole.
    <em>DEPRECATED.</em>
    @param role: an #AtspiRole object to query.
    @type role: Role
    @returns: a localizable string name for an #AtspiRole enumerated type.
    @rtype: str
    """
    return object

def set_main_context(cnx=None):
    """    Sets the main loop context that AT-SPI should assume is in use when
    setting an idle callback.
    This function should be called by application-side implementors (ie,
    at-spi2-atk) when it is desirable to re-enter the main loop.
    @param cnx: The #GMainContext to use.
    @type cnx: GLib.MainContext
    @returns: 
    @rtype: None
    """
    return object

def set_timeout(val=None, startup_time=None):
    """    Set the timeout used for method calls. If this is not set explicitly,
    a default of 0.8 ms is used.
    Note that at-spi2-registryd currently uses a timeout of 3 seconds when
    sending a keyboard event notification. This means that, if an AT makes
    a call in response to the keyboard notification and the application
    being called does not respond before the timeout is reached,
    at-spi2-registryd will time out on the keyboard event notification and
    pass the key onto the application (ie, reply to indicate that the key
    was not consumed), so this may make it undesirable to set a timeout
    larger than 3 seconds.
    
    By default, the normal timeout is set to 800 ms, and the application startup
    timeout is set to 15 seconds.
    @param val: The timeout value, in milliseconds, or -1 to disable the timeout.
    @param startup_time: The amount of time, in milliseconds, to allow to pass before enforcing timeouts on an application. Can be used to prevent timeout exceptions if an application is likely to block for an extended period of time on initialization. -1 can be passed to disable this behavior.
    @type val: int
    @type startup_time: int
    @returns: 
    @rtype: None
    """
    return object


class AccessibleClass():
    """"""

    @property
    def parent_class(self):
        return object


class AccessiblePrivate():
    """"""


class Action():
    """"""
    
    def do_action(self, i=None):
        """        Invoke the action indicated by #index.
        @param i: an integer specifying which action to invoke.
        @type i: int
        @returns: #TRUE if the action is successfully invoked, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def get_action_description(self, i=None):
        """        Get the description of '@i-th' action invocable on an
             object implementing #AtspiAction.
        @param i: an integer indicating which action to query.
        @type i: int
        @returns: a UTF-8 string describing the '@i-th' invocable action.
        @rtype: str
        """
        return object
    
    def get_action_name(self, i=None):
        """        Get the name of the '@i-th' action invocable on an
             object implementing #AtspiAction.
        @param i: an integer indicating which action to query.
        @type i: int
        @returns: the non-localized name of the action, as a UTF-8 string.
        @rtype: str
        """
        return object
    
    def get_description(self, i=None):
        """        Get the description of '@i-th' action invocable on an
             object implementing #AtspiAction.
        @param i: an integer indicating which action to query.
        @type i: int
        @returns: a UTF-8 string describing the '@i-th' invocable action.
        @rtype: str
        """
        return object
    
    def get_key_binding(self, i=None):
        """        Get the keybindings for the @i-th action invocable on an
             object implementing #AtspiAction, if any are defined.
             The keybindings string format is as follows:
               there are multiple parts to a keybinding string (typically 3).
               They are delimited with ";".  The first is the action's
               keybinding which is usable if the object implementing the action
               is currently posted to the screen, e.g. if a menu is posted
               then these keybindings for the corresponding menu-items are
               available.  The second keybinding substring is the full key sequence
               necessary to post the action's widget and activate it, e.g. for
               a menu item such as "File->Open" it would both post the menu and
               activate the item.  Thus the second keybinding string is available
               during the lifetime of the containing toplevel window as a whole,
               whereas the first keybinding string only works while the object
               implementing AtkAction is posted.  The third (and optional)
               keybinding string is the "keyboard shortcut" which invokes the
               action without posting any menus.
               Meta-keys are indicated by the conventional strings
               "&lt;Control&gt;", "&lt;Alt&gt;", "&lt;Shift&gt;", "&lt;Mod2&gt;",
               etc. (we use the same string as gtk_accelerator_name() in
               gtk+-2.X.
        @param i: an integer indicating which action to query.
        @type i: int
        @returns: a UTF-8 string which can be parsed to determine the @i-th
       invocable action's keybindings.
        @rtype: str
        """
        return object
    
    def get_localized_name(self, i=None):
        """        Get the name of the '@i-th' action invocable on an
             object implementing #AtspiAction.
        @param i: an integer indicating which action to query.
        @type i: int
        @returns: the name of the action, as a UTF-8 string.
        @rtype: str
        """
        return object
    
    def get_n_actions(self):
        """        Get the number of actions invokable on an #AtspiAction implementor.
        @returns: an integer indicating the number of invocable actions.
        @rtype: int
        """
        return object
    
    def get_name(self, i=None):
        """        Get the name of the '@i-th' action invocable on an
             object implementing #AtspiAction.
        @param i: an integer indicating which action to query.
        @type i: int
        @returns: the non-localized name of the action, as a UTF-8 string.
        @rtype: str
        """
        return object


class Application():
    """"""

    @property
    def parent(self):
        return object

    @property
    def hash(self):
        return object

    @property
    def bus_name(self):
        return object

    @property
    def bus(self):
        return object

    @property
    def root(self):
        return object

    @property
    def cache(self):
        return object

    @property
    def toolkit_name(self):
        return object

    @property
    def toolkit_version(self):
        return object

    @property
    def atspi_version(self):
        return object

    @property
    def time_added(self):
        return object


class ApplicationClass():
    """"""

    @property
    def parent_class(self):
        return object


class Collection():
    """"""
    
    def get_active_descendant(self):
        """        
        @returns: The active descendant of the given object. Not yet implemented.
        @rtype: Accessible
        """
        return object
    
    def get_matches(self, rule=None, sortby=None, count=None, traverse=None):
        """        Gets all #AtspiAccessible objects from the @collection matching a given
        @rule.
        @param rule: An #AtspiMatchRule describing the match criteria.
        @param sortby: An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
        @param count: The maximum number of results to return, or 0 for no limit.
        @param traverse: Not supported.
        @type rule: MatchRule
        @type sortby: CollectionSortOrder
        @type count: int
        @type traverse: bool
        @rtype: None
        """
        return object
    
    def get_matches_from(self, current_object=None, rule=None, sortby=None, tree=None, count=None, traverse=None):
        """        Gets all #AtspiAccessible objects from the @collection, before
        @current_object, matching a given @rule.
        @param current_object: Upon reaching this object, searching should stop.
        @param rule: An #AtspiMatchRule describing the match criteria.
        @param sortby: An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
        @param tree: An #AtspiCollectionTreeTraversalType specifying restrictions on          the objects to be traversed.
        @param count: The maximum number of results to return, or 0 for no limit.
        @param traverse: Not supported.
        @type current_object: Accessible
        @type rule: MatchRule
        @type sortby: CollectionSortOrder
        @type tree: CollectionTreeTraversalType
        @type count: int
        @type traverse: bool
        @rtype: None
        """
        return object
    
    def get_matches_to(self, current_object=None, rule=None, sortby=None, tree=None, limit_scope=None, count=None, traverse=None):
        """        Gets all #AtspiAccessible objects from the @collection, after
        @current_object, matching a given @rule.
        @param current_object: The object at which to start searching.
        @param rule: An #AtspiMatchRule describing the match criteria.
        @param sortby: An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
        @param tree: An #AtspiCollectionTreeTraversalType specifying restrictions on          the objects to be traversed.
        @param limit_scope: If #TRUE, only descendants of @current_object's parent          will be returned. Otherwise (if #FALSE), any accessible may be          returned if it would preceed @current_object in a flattened          hierarchy.
        @param count: The maximum number of results to return, or 0 for no limit.
        @param traverse: Not supported.
        @type current_object: Accessible
        @type rule: MatchRule
        @type sortby: CollectionSortOrder
        @type tree: CollectionTreeTraversalType
        @type limit_scope: bool
        @type count: int
        @type traverse: bool
        @rtype: None
        """
        return object
    
    def is_ancestor_of(self, test=None):
        """        Not yet implemented.
        @type test: Accessible
        @returns: 
        @rtype: bool
        """
        return object


class Component():
    """"""
    
    def contains(self, x=None, y=None, ctype=None):
        """        Queries whether a given #AtspiComponent contains a particular point.
        @param x: a #gint specifying the x coordinate in question.
        @param y: a #gint specifying the y coordinate in question.
        @param ctype: the desired coordinate system of the point (@x, @y)         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
        @type x: int
        @type y: int
        @type ctype: CoordType
        @returns: #TRUE if the specified component contains the point (@x, @y),
          #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_accessible_at_point(self, x=None, y=None, ctype=None):
        """        Gets the accessible child at a given coordinate within an #AtspiComponent.
        @param x: a #gint specifying the x coordinate of the point in question.
        @param y: a #gint specifying the y coordinate of the point in question.
        @param ctype: the coordinate system of the point (@x, @y)         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type x: int
        @type y: int
        @type ctype: CoordType
        @returns: a pointer to an
          #AtspiAccessible child of the specified component which
          contains the point (@x, @y), or NULL if no child contains
          the point.
        @rtype: Accessible
        """
        return object
    
    def get_alpha(self):
        """        Gets the opacity/alpha value of a component, if alpha blending is in use.
        @returns: the opacity value of a component, as a #gdouble between 0.0 and 1.0.
        @rtype: float
        """
        return object
    
    def get_extents(self, ctype=None):
        """        Gets the bounding box of the specified #AtspiComponent.
        @param ctype: the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type ctype: CoordType
        @returns: An #AtspiRect giving the accessible's extents.
        @rtype: Rect
        """
        return object
    
    def get_layer(self):
        """        Queries which layer the component is painted into, to help determine its
             visibility in terms of stacking order.
        @returns: the #AtspiComponentLayer into which this component is painted.
        @rtype: ComponentLayer
        """
        return object
    
    def get_mdi_z_order(self):
        """        Queries the z stacking order of a component which is in the MDI or window
              layer. (Bigger z-order numbers mean nearer the top)
        @returns: a #gshort indicating the stacking order of the component
       in the MDI layer, or -1 if the component is not in the MDI layer.
        @rtype: gshort
        """
        return object
    
    def get_position(self, ctype=None):
        """        Gets the minimum x and y coordinates of the specified #AtspiComponent.
        @param ctype: the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type ctype: CoordType
        @returns: An #AtspiPoint giving the @obj's position.
        @rtype: Point
        """
        return object
    
    def get_size(self):
        """        Gets the size of the specified #AtspiComponent.
        @returns: An #AtspiPoint giving the @obj's size.
        @rtype: Point
        """
        return object
    
    def grab_focus(self):
        """        Attempts to set the keyboard input focus to the specified
                #AtspiComponent.
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_extents(self, x=None, y=None, width=None, height=None, ctype=None):
        """        Moves and resizes the specified component.
        @param x: the new vertical position to which the component should be moved.
        @param y: the new horizontal position to which the component should be moved.
        @param width: the width to which the component should be resized.
        @param height: the height to which the component should be resized.
        @param ctype: the coordinate system in which the position is specified.         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type ctype: CoordType
        @returns: #TRUE if successful; #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_position(self, x=None, y=None, ctype=None):
        """        Moves the component to the specified position.
        @param x: the new vertical position to which the component should be moved.
        @param y: the new horizontal position to which the component should be moved.
        @param ctype: the coordinate system in which the position is specified.         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type x: int
        @type y: int
        @type ctype: CoordType
        @returns: #TRUE if successful; #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_size(self, width=None, height=None):
        """        Resizes the specified component to the given coordinates.
        @param width: the width to which the component should be resized.
        @param height: the height to which the component should be resized.
        @type width: int
        @type height: int
        @returns: #TRUE if successful; #FALSE otherwise.
        @rtype: bool
        """
        return object


class DeviceEvent():
    """"""

    @property
    def type(self):
        return object

    @property
    def id(self):
        return object

    @property
    def hw_code(self):
        return object

    @property
    def modifiers(self):
        return object

    @property
    def timestamp(self):
        return object

    @property
    def event_string(self):
        return object

    @property
    def is_text(self):
        return object


class DeviceListener(GObject.Object):
    """"""
    
    def __init__(self, callback=None, user_data=None, callback_destroyed=None):
        """        Creates a new #AtspiDeviceListener with a specified callback function.
        @param callback: an #AtspiDeviceListenerCB callback function,            or NULL.
        @param user_data: a pointer to data which will be passed to the callback when invoked.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed. It can be NULL.
        @type callback: DeviceListenerCB
        @type user_data: gpointer
        @type callback_destroyed: GLib.DestroyNotify
        @returns: Newly created DeviceListener
        @rtype: DeviceListener
        """
        return object
    @staticmethod
    def new(callback=None, user_data=None, callback_destroyed=None):
        """        Creates a new #AtspiDeviceListener with a specified callback function.
        @param callback: an #AtspiDeviceListenerCB callback function,            or NULL.
        @param user_data: a pointer to data which will be passed to the callback when invoked.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed. It can be NULL.
        @type callback: DeviceListenerCB
        @type user_data: gpointer
        @type callback_destroyed: GLib.DestroyNotify
        @returns: Newly created DeviceListener
        @rtype: DeviceListener
        """
        return object
    @staticmethod
    def new_simple(callback=None, callback_destroyed=None):
        """        Creates a new #AtspiDeviceListener with a specified callback function.
        This method is similar to #atspi_device_listener_new, but callback
        takes no user data.
        @param callback: an #AtspiDeviceListenerCB callback function,            or NULL.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed.  It an be NULL.
        @type callback: DeviceListenerSimpleCB
        @type callback_destroyed: GLib.DestroyNotify
        @returns: Newly created DeviceListener
        @rtype: DeviceListener
        """
        return object
    
    def device_event(self, event=None):
        """        
        @type event: DeviceEvent
        @returns: 
        @rtype: bool
        """
        return object
    
    def add_callback(self, callback=None, callback_destroyed=None, user_data=None):
        """        Adds an in-process callback function to an existing #AtspiDeviceListener.
        @param callback: an #AtspiDeviceListenerCB function pointer.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed. It can be NULL.
        @param user_data: a pointer to data which will be passed to the             callback when invoked.
        @type callback: DeviceListenerCB
        @type callback_destroyed: GLib.DestroyNotify
        @type user_data: gpointer
        @returns: 
        @rtype: None
        """
        return object
    
    def remove_callback(self, callback=None):
        """        Removes an in-process callback function from an existing
        #AtspiDeviceListener.
        @param callback: an #AtspiDeviceListenerCB function pointer.
        @type callback: DeviceListenerCB
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def id(self):
        return object

    @property
    def callbacks(self):
        return object


class DeviceListenerClass():
    """"""

    @property
    def parent_class(self):
        return object

    @property
    def device_event(self):
        return object


class Document():
    """"""
    
    def get_attribute_value(self, attribute=None):
        """        Gets the value of a single attribute, if specified for the document as a whole.
        @param attribute: a string indicating the name of a specific attribute.
        @type attribute: str
        @returns: a string corresponding to the value of the specified attribute, or an empty string if the attribute is unspecified for the object.
        @rtype: str
        """
        return object
    
    def get_attributes(self):
        """        Gets all constant attributes for the document as a whole. For attributes
        that change within the document content, see @atspi_text_get_attribute_run instead.
        @returns: a #GHashTable
          containing the constant attributes of the document, as name-value pairs.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_current_page_number(self):
        """        Gets the current page number of an #AccessibleDocument object.
        @returns: a #gint indicating the current page number in the #AccessibleDocument object.
        @rtype: int
        """
        return object
    
    def get_document_attribute_value(self, attribute=None):
        """        Gets the value of a single attribute, if specified for the document as a whole.
        @param attribute: a string indicating the name of a specific attribute.
        @type attribute: str
        @returns: a string corresponding to the value of the specified attribute, or an empty string if the attribute is unspecified for the object.
        @rtype: str
        """
        return object
    
    def get_document_attributes(self):
        """        Gets all constant attributes for the document as a whole. For attributes
        that change within the document content, see @atspi_text_get_attribute_run instead.
        @returns: a #GHashTable
          containing the constant attributes of the document, as name-value pairs.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_locale(self):
        """        Gets the locale associated with the document's content,
        e.g. the locale for LOCALE_TYPE_MESSAGES.
        @returns: a string compliant with the POSIX standard for locale description.
        @rtype: str
        """
        return object
    
    def get_page_count(self):
        """        Gets the page count of an #AccessibleDocument object.
        @returns: a #gint indicating the page count of an #AccessibleDocument object.
        @rtype: int
        """
        return object


class EditableText():
    """"""
    
    def copy_text(self, start_pos=None, end_pos=None):
        """        Copies text from an #AtspiEditableText object into the system clipboard.
        
        see: #atspi_editable_text_paste_text
        @param start_pos: a #gint indicating the starting character offset       of the text to copy.
        @param end_pos: a #gint indicating the offset of the first character       past the end of the text section to be copied.
        @type start_pos: int
        @type end_pos: int
        @returns: #TRUE if the operation was successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def cut_text(self, start_pos=None, end_pos=None):
        """        Deletes text from an #AtspiEditableText object, copying the
              excised portion into the system clipboard.
        
        see: #atspi_editable_text_paste_text
        @param start_pos: a #gint indicating the starting character offset       of the text to cut.
        @param end_pos: a #gint indicating the offset of the first character       past the end of the text section to be cut.
        @type start_pos: int
        @type end_pos: int
        @returns: #TRUE if operation was successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def delete_text(self, start_pos=None, end_pos=None):
        """        Deletes text from an #AtspiEditableText object, without copying the
              excised portion into the system clipboard.
        
        see: #atspi_editable_text_cut_text
        @param start_pos: a #gint indicating the starting character offset       of the text to delete.
        @param end_pos: a #gint indicating the offset of the first character       past the end of the text section to be deleted.
        @type start_pos: int
        @type end_pos: int
        @returns: #TRUE if the operation was successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def insert_text(self, position=None, text=None, length=None):
        """        Inserts text into an #AtspiEditableText object.
        As with all character offsets, the specified @position may not be the
        same as the resulting byte offset, since the text is in a
        variable-width encoding.
        @param position: a #gint indicating the character offset at which to insert       the new text.
        @param text: a string representing the text to insert, in UTF-8 encoding.
        @param length: the number of characters of text to insert. If the character count of text is less than or equal to length, the entire contents of text will be inserted.
        @type position: int
        @type text: str
        @type length: int
        @returns: #TRUE if the operation was successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def paste_text(self, position=None):
        """        Inserts text from the system clipboard into an #AtspiEditableText object.
        As with all character offsets, the specified @position may not be the
              same as the resulting byte offset, since the text is in a
              variable-width encoding.
        @param position: a #gint indicating the character offset at which to insert       the new text.
        @type position: int
        @returns: #TRUE if the operation was successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def set_text_contents(self, new_contents=None):
        """        Replace the entire text contents of an #AtspiEditableText object.
        @param new_contents: a character string, encoded in UTF-8, which is to      become the new text contents of the #AtspiEditableText object.
        @type new_contents: str
        @returns: #TRUE if the operation was successful, otherwise #FALSE.
        @rtype: bool
        """
        return object


class Event():
    """"""
    @staticmethod
    def main():
        """        Starts/enters the main event loop for the AT-SPI services.
        
        NOTE: This method does not return control; it is exited via a call to
        #atspi_event_quit from within an event handler.
        @returns: 
        @rtype: None
        """
        return object
    @staticmethod
    def quit():
        """        Quits the last main event loop for the AT-SPI services,
        See: #atspi_event_main
        @returns: 
        @rtype: None
        """
        return object

    @property
    def type(self):
        return object

    @property
    def source(self):
        return object

    @property
    def detail1(self):
        return object

    @property
    def detail2(self):
        return object

    @property
    def any_data(self):
        return object


class EventListener(GObject.Object):
    """"""
    
    def __init__(self, callback=None, user_data=None, callback_destroyed=None):
        """        Creates a new #AtspiEventListener associated with a specified @callback.
        @param callback: An #AtspiEventListenerCB to be called when an event is fired.
        @param user_data: data to pass to the callback.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed.  Can be NULL.
        @type callback: EventListenerCB
        @type user_data: gpointer
        @type callback_destroyed: GLib.DestroyNotify
        @returns: Newly created EventListener
        @rtype: EventListener
        """
        return object
    @staticmethod
    def new(callback=None, user_data=None, callback_destroyed=None):
        """        Creates a new #AtspiEventListener associated with a specified @callback.
        @param callback: An #AtspiEventListenerCB to be called when an event is fired.
        @param user_data: data to pass to the callback.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed.  Can be NULL.
        @type callback: EventListenerCB
        @type user_data: gpointer
        @type callback_destroyed: GLib.DestroyNotify
        @returns: Newly created EventListener
        @rtype: EventListener
        """
        return object
    @staticmethod
    def new_simple(callback=None, callback_destroyed=None):
        """        Creates a new #AtspiEventListener associated with a specified @callback.
        @param callback: An #AtspiEventListenerSimpleCB to be called when an event is fired.
        @param callback_destroyed: A #GDestroyNotify called when the listener is freed and data associated with the callback should be freed.  Can be NULL.
        @type callback: EventListenerSimpleCB
        @type callback_destroyed: GLib.DestroyNotify
        @returns: Newly created EventListener
        @rtype: EventListener
        """
        return object
    @staticmethod
    def deregister_from_callback(callback=None, user_data=None, event_type=None):
        """        Deregisters an #AtspiEventListenerCB from the registry, for a specific
                    event type.
        @param callback: the #AtspiEventListenerCB registered against an            event type.
        @param user_data: User data that was passed in for this callback.
        @param event_type: a string specifying the event type for which this             listener is to be deregistered.
        @type callback: EventListenerCB
        @type user_data: gpointer
        @type event_type: str
        @returns: #TRUE if successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    @staticmethod
    def deregister_no_data(callback=None, event_type=None):
        """        deregisters an #AtspiEventListenerSimpleCB from the registry, for a specific
                    event type.
        @param callback: the #AtspiEventListenerSimpleCB registered against            an event type.
        @param event_type: a string specifying the event type for which this             listener is to be deregistered.
        @type callback: EventListenerSimpleCB
        @type event_type: str
        @returns: #TRUE if successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    @staticmethod
    def register_from_callback(callback=None, user_data=None, callback_destroyed=None, event_type=None):
        """        Registers an #AtspiEventListenerCB against an @event_type.
        @param callback: the #AtspiEventListenerCB to be registered against an event type.
        @param user_data: User data to be passed to the callback.
        @param callback_destroyed: A #GDestroyNotify called when the callback is destroyed.
        @param event_type: a character string indicating the type of events for which            notification is requested.  See #atspi_event_listener_register for a description of the format.
        @type callback: EventListenerCB
        @type user_data: gpointer
        @type callback_destroyed: GLib.DestroyNotify
        @type event_type: str
        @returns: #TRUE if successfull, otherwise #FALSE.
        @rtype: bool
        """
        return object
    @staticmethod
    def register_from_callback_full(callback=None, user_data=None, callback_destroyed=None, event_type=None, properties=None):
        """        
        @param callback: an #AtspiEventListenerCB function pointer.
        @type callback: EventListenerCB
        @type user_data: gpointer
        @type callback_destroyed: GLib.DestroyNotify
        @type event_type: str
        @returns: #TRUE if successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    @staticmethod
    def register_no_data(callback=None, callback_destroyed=None, event_type=None):
        """        Registers an #AtspiEventListenetSimpleCB. The method is similar to
        #atspi_event_listener_register, but @callback takes no user_data.
        @param callback: the #AtspiEventListenerSimpleCB to be            registered against an event type.
        @param callback_destroyed: A #GDestroyNotify called when the callback is destroyed.
        @param event_type: a character string indicating the type of events for which            notification is requested.  Format is            EventClass:major_type:minor_type:detail            where all subfields other than EventClass are optional.            EventClasses include "object", "window", "mouse",            and toolkit events (e.g. "Gtk", "AWT").            Examples: "focus:", "Gtk:GtkWidget:button_press_event".
        @type callback: EventListenerSimpleCB
        @type callback_destroyed: GLib.DestroyNotify
        @type event_type: str
        @returns: #TRUE if successfull, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def deregister(self, event_type=None):
        """        Deregisters an #AtspiEventListener from the registry, for a specific
                    event type.
        @param event_type: a string specifying the event type for which this             listener is to be deregistered.
        @type event_type: str
        @returns: #TRUE if successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def register(self, event_type=None):
        """        Adds an in-process callback function to an existing #AtspiEventListener.
        
        Legal object event types:
        
           (property change events)
        
                   object:property-change
                   object:property-change:accessible-name
                   object:property-change:accessible-description
                   object:property-change:accessible-parent
                   object:property-change:accessible-value
                   object:property-change:accessible-role
                   object:property-change:accessible-table-caption
                   object:property-change:accessible-table-column-description
                   object:property-change:accessible-table-column-header
                   object:property-change:accessible-table-row-description
                   object:property-change:accessible-table-row-header
                   object:property-change:accessible-table-summary
        
           (other object events)
        
                   object:state-changed
                   object:children-changed
                   object:visible-data-changed
                   object:selection-changed
                   object:text-selection-changed
                   object:text-changed
                   object:text-caret-moved
                   object:row-inserted
                   object:row-reordered
                   object:row-deleted
                   object:column-inserted
                   object:column-reordered
                   object:column-deleted
                   object:model-changed
                   object:active-descendant-changed
        
         (window events)
        
                   window:minimize
                   window:maximize
                   window:restore
                   window:close
                   window:create
                   window:reparent
                   window:desktop-create
                   window:desktop-destroy
                   window:activate
                   window:deactivate
                   window:raise
                   window:lower
                   window:move
                   window:resize
                   window:shade
                   window:unshade
                   window:restyle
        
         (other events)
        
                   focus:
                   mouse:abs
                   mouse:rel
                   mouse:b1p
                   mouse:b1r
                   mouse:b2p
                   mouse:b2r
                   mouse:b3p
                   mouse:b3r
        
        NOTE: this character string may be UTF-8, but should not contain byte
        value 56
                   (ascii ':'), except as a delimiter, since non-UTF-8 string
                   delimiting functions are used internally.
                   In general, listening to
                   toolkit-specific events is not recommended.
        @param event_type: a character string indicating the type of events for which            notification is requested.  Format is            EventClass:major_type:minor_type:detail            where all subfields other than EventClass are optional.            EventClasses include "object", "window", "mouse",            and toolkit events (e.g. "Gtk", "AWT").            Examples: "focus:", "Gtk:GtkWidget:button_press_event".
        @type event_type: str
        @returns: #TRUE if successful, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def register_full(self, event_type=None, properties=None):
        """        Adds an in-process callback function to an existing #AtspiEventListener.
        @param event_type: a character string indicating the type of events for which            notification is requested.  See #atspi_event_listener_register for a description of the format and legal event types.
        @param properties: a list of             properties that should be sent along with the event. The             properties are valued for the duration of the event callback.k             TODO: Document.
        @type event_type: str
        @returns: #TRUE if successful, otherwise #FALSE.
        @rtype: bool
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def callback(self):
        return object

    @property
    def user_data(self):
        return object

    @property
    def cb_destroyed(self):
        return object


class EventListenerClass():
    """"""

    @property
    def parent_class(self):
        return object


class EventListenerMode():
    """"""

    @property
    def synchronous(self):
        return object

    @property
    def preemptive(self):
        return object

    @property
    def global(self):
        return object


class HyperlinkClass():
    """"""

    @property
    def parent_class(self):
        return object


class Hypertext():
    """"""
    
    def get_link(self, link_index=None):
        """        Gets the #AtspiHyperlink object at a specified index.
        @param link_index: a (zero-index) #gint indicating which hyperlink to query.
        @type link_index: int
        @returns: the #AtspiHyperlink object
          specified by @link_index.
        @rtype: Hyperlink
        """
        return object
    
    def get_link_index(self, character_offset=None):
        """        Gets the index of the #AtspiHyperlink object at a specified
               character offset.
        @param character_offset: a #gint specifying the character offset to query.
        @type character_offset: int
        @returns: the linkIndex of the #AtspiHyperlink active at
        character offset @character_offset, or -1 if there is
        no hyperlink at the specified character offset.
        @rtype: int
        """
        return object
    
    def get_n_links(self):
        """        Gets the total number of #AtspiHyperlink objects that an
        #AtspiHypertext implementor has.
        @returns: a #gint indicating the number of #AtspiHyperlink objects
        of the #AtspiHypertext implementor, or -1 if
        the number cannot be determined (for example, if the
        #AtspiHypertext object is so large that it is not
        all currently in the memory cache).
        @rtype: int
        """
        return object


class Image():
    """"""
    
    def get_image_description(self):
        """        Gets the description of the image displayed in an #AtspiImage object.
        @returns: a UTF-8 string describing the image.
        @rtype: str
        """
        return object
    
    def get_image_extents(self, ctype=None):
        """        Gets the bounding box of the image displayed in a
                specified #AtspiImage implementor.
        @param ctype: the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type ctype: CoordType
        @returns: a pointer to an #AtspiRect corresponding to the image's bounding box. The minimum x and y coordinates, width, and height are specified.
        @rtype: Rect
        """
        return object
    
    def get_image_locale(self):
        """        Gets the locale associated with an image and its textual representation.
        @returns: A POSIX LC_MESSAGES-style locale value for image description and text.
        @rtype: str
        """
        return object
    
    def get_image_position(self, ctype=None):
        """        Gets the minimum x and y coordinates of the image displayed in a
                specified #AtspiImage implementor.
        @param ctype: the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
        @type ctype: CoordType
        @returns: a pointer to an #AtspiPoint where x and y correspond to the minimum coordinates of the displayed image.
        @rtype: Point
        """
        return object
    
    def get_image_size(self):
        """        Gets the size of the image displayed in a specified #AtspiImage object.
        @returns: a pointer to an #AtspiPoint where x corresponds to the image's width and y corresponds to the image's height.
        @rtype: Point
        """
        return object


class KeyDefinition():
    """"""

    @property
    def keycode(self):
        return object

    @property
    def keysym(self):
        return object

    @property
    def keystring(self):
        return object

    @property
    def unused(self):
        return object


class KeySet():
    """Structure containing identifying information about a set of keycode or
       keysyms."""

    @property
    def keysyms(self):
        return object

    @property
    def keycodes(self):
        return object

    @property
    def keystrings(self):
        return object

    @property
    def len(self):
        return object


class MatchRule(GObject.Object):
    """"""
    
    def __init__(self, states=None, statematchtype=None, attributes=None, attributematchtype=None, roles=None, rolematchtype=None, interfaces=None, interfacematchtype=None, invert=None):
        """        Creates a new #AtspiMatchRule with specified @states, @attributes,
        @interfaces, and @roles.
        @param states: An #AtspiStateSet specifying the states to match or NULL if none.
        @param statematchtype: An #AtspiCollectionMatchType specifying how to interpret          @states.
        @param attributes: A #GHashTable specifying          attributes to match. To specify multiple attribute values,          separate each value with a :: If an attribute value contains a :,          then it can be escaped by preceding it with a \. A backslash can          likewise be escaped by inserting a double backslash.
        @param attributematchtype: An #AtspiCollectionMatchType specifying how to          interpret @attributes.
        @param roles: A #GArray of roles to match, or NULL if          not applicable.
        @param rolematchtype: An #AtspiCollectionMatchType specifying how to          interpret @roles.
        @param interfaces: An array of interfaces to match, or          NULL if not applicable.  Interface names should be specified          by their DBus names (org.a11y.Atspi.Accessible,          org.a11y.Atspi.Component, etc).
        @param interfacematchtype: An #AtspiCollectionMatchType specifying how to          interpret @interfaces.
        @param invert: if #TRUE, the match rule should be denied (inverted); if #FALSE,          it should not. For example, if the match rule defines that a match is          an object of ROLE_HEADING which has STATE_FOCUSABLE and a click action,          inverting it would match all objects that are not of ROLE_HEADING,          focusable and clickable at the same time.
        @type states: StateSet
        @type statematchtype: CollectionMatchType
        @type attributes: GLib.HashTable
        @type attributematchtype: CollectionMatchType
        @type rolematchtype: CollectionMatchType
        @type interfacematchtype: CollectionMatchType
        @type invert: bool
        @returns: Newly created MatchRule
        @rtype: MatchRule
        """
        return object
    @staticmethod
    def new(states=None, statematchtype=None, attributes=None, attributematchtype=None, roles=None, rolematchtype=None, interfaces=None, interfacematchtype=None, invert=None):
        """        Creates a new #AtspiMatchRule with specified @states, @attributes,
        @interfaces, and @roles.
        @param states: An #AtspiStateSet specifying the states to match or NULL if none.
        @param statematchtype: An #AtspiCollectionMatchType specifying how to interpret          @states.
        @param attributes: A #GHashTable specifying          attributes to match. To specify multiple attribute values,          separate each value with a :: If an attribute value contains a :,          then it can be escaped by preceding it with a \. A backslash can          likewise be escaped by inserting a double backslash.
        @param attributematchtype: An #AtspiCollectionMatchType specifying how to          interpret @attributes.
        @param roles: A #GArray of roles to match, or NULL if          not applicable.
        @param rolematchtype: An #AtspiCollectionMatchType specifying how to          interpret @roles.
        @param interfaces: An array of interfaces to match, or          NULL if not applicable.  Interface names should be specified          by their DBus names (org.a11y.Atspi.Accessible,          org.a11y.Atspi.Component, etc).
        @param interfacematchtype: An #AtspiCollectionMatchType specifying how to          interpret @interfaces.
        @param invert: if #TRUE, the match rule should be denied (inverted); if #FALSE,          it should not. For example, if the match rule defines that a match is          an object of ROLE_HEADING which has STATE_FOCUSABLE and a click action,          inverting it would match all objects that are not of ROLE_HEADING,          focusable and clickable at the same time.
        @type states: StateSet
        @type statematchtype: CollectionMatchType
        @type attributes: GLib.HashTable
        @type attributematchtype: CollectionMatchType
        @type rolematchtype: CollectionMatchType
        @type interfacematchtype: CollectionMatchType
        @type invert: bool
        @returns: Newly created MatchRule
        @rtype: MatchRule
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def states(self):
        return object

    @property
    def statematchtype(self):
        return object

    @property
    def attributes(self):
        return object

    @property
    def attributematchtype(self):
        return object

    @property
    def interfaces(self):
        return object

    @property
    def interfacematchtype(self):
        return object

    @property
    def roles(self):
        return object

    @property
    def rolematchtype(self):
        return object

    @property
    def invert(self):
        return object


class MatchRuleClass():
    """"""

    @property
    def parent_class(self):
        return object


class Object(GObject.Object):
    """"""

    @property
    def parent(self):
        return object

    @property
    def app(self):
        return object

    @property
    def path(self):
        return object


class ObjectClass():
    """"""

    @property
    def parent_class(self):
        return object


class Point():
    """"""
    
    def copy(self):
        """        
        @returns: 
        @rtype: Point
        """
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object


class Range():
    """"""
    
    def copy(self):
        """        Gets a copy of an #AtspiRange object.
        @returns: the #AtspiRange copy of an #AtspiRange object.
        @rtype: Range
        """
        return object

    @property
    def start_offset(self):
        return object

    @property
    def end_offset(self):
        return object


class Rect():
    """"""
    
    def copy(self):
        """        
        @returns: 
        @rtype: Rect
        """
        return object

    @property
    def x(self):
        return object

    @property
    def y(self):
        return object

    @property
    def width(self):
        return object

    @property
    def height(self):
        return object


class Relation(GObject.Object):
    """"""
    
    def get_n_targets(self):
        """        Gets the number of objects which this relationship has as its
              target objects (the subject is the #AtspiAccessible from which this
              #AtspiRelation originated).
        @returns: a #gint indicating how many target objects which the
       originating #AtspiAccessible object has the #AtspiRelation
       relationship with.
        @rtype: int
        """
        return object
    
    def get_relation_type(self):
        """        Gets the type of relationship represented by an #AtspiRelation.
        @returns: an #AtspiRelationType indicating the type of relation
         encapsulated in this #AtspiRelation object.
        @rtype: RelationType
        """
        return object
    
    def get_target(self, i=None):
        """        Gets the @i-th target of a specified #AtspiRelation relationship.
        @param i: a (zero-index) #gint indicating which (of possibly several) target is requested.
        @type i: int
        @returns: an #AtspiAccessible which is the @i-th object
          with which the originating #AtspiAccessible has relationship
          specified in the #AtspiRelation object.
        @rtype: Accessible
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def relation_type(self):
        return object

    @property
    def targets(self):
        return object


class RelationClass():
    """"""

    @property
    def parent_class(self):
        return object


class Selection():
    """"""
    
    def clear_selection(self):
        """        Clears the current selection, removing all selected children from the
              specified #AtspiSelection implementor's selection list.
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def deselect_child(self, child_index=None):
        """        Deselects a specific child of an #AtspiSelection.
                 Note that @child_index is the index of the child
                 in the parent container.
        
        See #atspi_selection_deselect_selected_child
        @param child_index: a #gint indicating which of the children              of the #AtspiAccessible is to be de-selected.
        @type child_index: int
        @returns: #TRUE if the child was successfully deselected, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def deselect_selected_child(self, selected_child_index=None):
        """        Removes a child from the selected children list of an #AtspiSelection.
                 Note that @child_index is the index in the selected-children list,
                 not the index in the parent container.  @selectedChildIndex in this
                 method, and @child_index in #atspi_selection_select_child
                 are asymmetric.
        @param selected_child_index: a #gint indicating which of the selected children              of the #Accessible is to be selected.
        @type selected_child_index: int
        @returns: #TRUE if the child was successfully deselected, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_n_selected_children(self):
        """        Gets the number of children of an #AtspiSelection implementor which are
               currently selected.
        @returns: a #gint indicating the number of #Accessible children
        of the #AtspiSelection implementor which are currently selected.
        @rtype: int
        """
        return object
    
    def get_selected_child(self, selected_child_index=None):
        """        Gets the i-th selected #AtspiAccessible child of an #AtspiSelection.
             Note that @selected_child_index refers to the index in the list
             of 'selected'
             children and generally differs from that used in
             #atspi_accessible_get_child_at_index or returned by
             #atspi_accessible_get_index_in_parent.
             @selected_child_index must lie between 0
             and #atspi_selection_get_n_selected_children - 1, inclusive.
        @param selected_child_index: a #gint indicating which of the selected      children is specified.
        @type selected_child_index: int
        @returns: a pointer to a selected #AtspiAccessible child
          object, specified by @selected_child_index.
        @rtype: Accessible
        """
        return object
    
    def is_child_selected(self, child_index=None):
        """        Determines whether a particular child of an #AtspiSelection implementor
               is currently selected.  Note that @child_index is the index into the
               standard #AtspiAccessible container's list of children.
        @param child_index: an index into the #AtspiSelection's list of children.
        @type child_index: int
        @returns: #TRUE if the specified child is currently selected,
          #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def select_all(self):
        """        Attempts to select all of the children of an #AtspiSelection implementor.
        Not all #AtspiSelection implementors support this operation.
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def select_child(self, child_index=None):
        """        Adds a child to the selected children list of an #AtspiSelection.
                For #AtspiSelection implementors that only allow
                single selections, this may replace the (single) current
                selection.
        @param child_index: a #gint indicating which child of the #Accessible              is to be selected.
        @type child_index: int
        @returns: #TRUE if the child was successfully selected, #FALSE otherwise.
        @rtype: bool
        """
        return object


class StateSet(GObject.Object):
    """"""
    
    def __init__(self, states=None):
        """        Generates an #AtspiStateSet with the given @states.
        @param states: An array of states with which the          method initializes the state set.
        @returns: Newly created StateSet
        @rtype: StateSet
        """
        return object
    @staticmethod
    def new(states=None):
        """        Generates an #AtspiStateSet with the given @states.
        @param states: An array of states with which the          method initializes the state set.
        @returns: Newly created StateSet
        @rtype: StateSet
        """
        return object
    
    def add(self, state=None):
        """        Adds a particular #AtspiState to an #AtspiStateSet (i.e. sets the
              given state to #TRUE in the stateset).
        @param state: an #AtspiStateType to be added to the specified #AtspiStateSet.
        @type state: StateType
        @returns: 
        @rtype: None
        """
        return object
    
    def compare(self, set2=None):
        """        Determines the differences between two instances of #AtspiStateSet.
        
        @see #atspi_state_set_equals.
        @param set2: a pointer to the second #AtspiStateSet object on which to operate.
        @type set2: StateSet
        @returns: an #AtspiStateSet object containing all states contained on one of the two sets but not the other.
        @rtype: StateSet
        """
        return object
    
    def contains(self, state=None):
        """        Determines whether a given #AtspiStateSet includes a given state; that is,
                 whether @state is true for the @set in question.
        @param state: an #AtspiStateType for which the specified #AtspiStateSet          will be queried.
        @type state: StateType
        @returns: #TRUE if @state is true/included in the given #AtspiStateSet,
          otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def equals(self, set2=None):
        """        Determines whether two instances of #AtspiStateSet are equivalent (i.e.
                 consist of the same #AtspiStates).  Useful for checking multiple
                 state variables at once.
        
        @see #atspi_state_set_compare.
        @param set2: a pointer to the second #AtspiStateSet object on which to operate.
        @type set2: StateSet
        @returns: #TRUE if the two #AtspiStateSets are equivalent, otherwise #FALSE.
        @rtype: bool
        """
        return object
    
    def get_states(self):
        """        Returns the states in an #AtspiStateSet as an array.
        @rtype: None
        """
        return object
    
    def is_empty(self):
        """        
        @returns: #TRUE if the state set contains no states; #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def remove(self, state=None):
        """        Removes a particular #AtspiState to an #AtspiStateSet (i.e. sets the
              given state to #FALSE in the stateset.)
        @param state: an #AtspiStateType to remove from the specified @set.
        @type state: StateType
        @returns: 
        @rtype: None
        """
        return object
    
    def set_by_name(self, name=None, enabled=None):
        """        Enables/disables a state in an #AtspiStateSet according to its @name.
        @param name: a string corresponding to a state name.
        @param enabled: if #TRUE, @name should be enabled in the @set in question;          otherwise, it should be disabled.
        @type name: str
        @type enabled: bool
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def accessible(self):
        return object

    @property
    def states(self):
        return object


class StateSetClass():
    """"""

    @property
    def parent_class(self):
        return object


class Table():
    """"""
    
    def add_column_selection(self, column=None):
        """        Selects the specified column, adding it to the current column selection.
        Not all tables support column selection.
        @param column: the zero-indexed column number of the column being selected.
        @type column: int
        @returns: #TRUE if the specified column was successfully selected, #FALSE if not.
        @rtype: bool
        """
        return object
    
    def add_row_selection(self, row=None):
        """        Selects the specified row, adding it to the current row selection.
        Not all tables support row selection.
        @param row: the zero-indexed row number of the row being selected.
        @type row: int
        @returns: #TRUE if the specified row was successfully selected, #FALSE if not.
        @rtype: bool
        """
        return object
    
    def get_accessible_at(self, row=None, column=None):
        """        Gets the table cell at the specified row and column indices.
        To get the accessible object at a particular (x, y) screen
        coordinate, use #atspi_component_get_accessible_at_point.
        @param row: the specified table row, zero-indexed.
        @param column: the specified table column, zero-indexed.
        @type row: int
        @type column: int
        @returns: an #AtspiAccessible object representing the
          specified table cell.
        @rtype: Accessible
        """
        return object
    
    def get_caption(self):
        """        Gets an accessible representation of the caption for an #AtspiTable.
        @returns: an #AtspiAccessible object that serves as the table's caption.
        @rtype: Accessible
        """
        return object
    
    def get_column_at_index(self, index=None):
        """        Gets the table column index occupied by the child at a particular 1-D
        child index.
        
        @see #atspi_table_get_index_at, #atspi_table_get_row_at_index
        @param index: the specified child index, zero-indexed.
        @type index: int
        @returns: a #gint indicating the first column spanned by the child of a
          table, at the specified 1-D (zero-offset) @index.
        @rtype: int
        """
        return object
    
    def get_column_description(self, column=None):
        """        Gets a text description of a particular table column.  This differs from
        #atspi_table_get_column_header, which returns an #Accessible.
        @param column: the specified table column, zero-indexed.
        @type column: int
        @returns: a UTF-8 string describing the specified table column, if available.
        @rtype: str
        """
        return object
    
    def get_column_extent_at(self, row=None, column=None):
        """        Gets the number of columns spanned by the table cell at the specific
        row and column (some tables can have cells which span multiple
        rows and/or columns).
        @param row: the specified table row, zero-indexed.
        @param column: the specified table column, zero-indexed.
        @type row: int
        @type column: int
        @returns: a #gint indicating the number of columns spanned by the specified cell.
        @rtype: int
        """
        return object
    
    def get_column_header(self, column=None):
        """        Gets the header associated with a table column, if available.
        This differs from #atspi_table_get_column_description, which
        returns a string.
        @param column: the specified table column, zero-indexed.
        @type column: int
        @returns: an #AtspiAccessible representation of the
          specified table column, if available.
        @rtype: Accessible
        """
        return object
    
    def get_index_at(self, row=None, column=None):
        """        Gets the 1-D child index corresponding to the specified 2-D row and
        column indices. To get the accessible object at a particular (x, y) screen
        coordinate, use #atspi_component_get_accessible_at_point.
        
        @see #atspi_table_get_row_at_index, #atspi_table_get_column_at_index
        @param row: the specified table row, zero-indexed.
        @param column: the specified table column, zero-indexed.
        @type row: int
        @type column: int
        @returns: a #gint which serves as the index of a specified cell in the
          table, in a form usable by #atspi_get_child_at_index.
        @rtype: int
        """
        return object
    
    def get_n_columns(self):
        """        Gets the number of columns in an #AtspiTable,
               exclusive of any columns that are programmatically hidden, but inclusive
               of columns that may be outside of the current scrolling window or viewport.
        @returns: a #gint indicating the number of columns in the table.
        @rtype: int
        """
        return object
    
    def get_n_rows(self):
        """        Gets the number of rows in an #AtspiTable,
               exclusive of any rows that are programmatically hidden, but inclusive
               of rows that may be outside of the current scrolling window or viewport.
        @returns: a #gint indicating the number of rows in the table.
        @rtype: int
        """
        return object
    
    def get_n_selected_columns(self):
        """        Queries a table to find out how many columns are currently selected.
        Not all tables support column selection.
        @returns: a #gint indicating the number of columns currently selected.
        @rtype: int
        """
        return object
    
    def get_n_selected_rows(self):
        """        Query a table to find out how many rows are currently selected.
        Not all tables support row selection.
        @returns: a #gint indicating the number of rows currently selected.
        @rtype: int
        """
        return object
    
    def get_row_at_index(self, index=None):
        """        Gets the table row index occupied by the child at a particular 1-D
        child index.
        
        @see #atspi_table_get_index_at, #atspi_table_get_column_at_index
        @param index: the specified child index, zero-indexed.
        @type index: int
        @returns: a #gint indicating the first row spanned by the child of a
          table, at the specified 1-D (zero-offset) @index.
        @rtype: int
        """
        return object
    
    def get_row_column_extents_at_index(self, index=None, row=None, col=None, row_extents=None, col_extents=None, is_selected=None):
        """        Given a child index, determines the row and column indices and
        extents, and whether the cell is currently selected.  If
        the child at index is not a cell (for instance, if it is
        a summary, caption, etc.), #FALSE is returned.
        
        Example:
        If the #AtspiTable child at index '6' extends across columns 5 and 6 of
        row 2 of an #AtspiTable instance, and is currently selected, then
        
        retval = atspi_table_get_row_column_extents_at_index (table, 6,
                                                    row, col,
                                                    row_extents,
                                                    col_extents,
                                                    is_selected);
        
        will return #TRUE, and after the call
        row, col, row_extents, col_extents,
        and is_selected will contain 2, 5, 1, 2, and
        #TRUE, respectively.
        @param index: the index of the #AtspiTable child whose row/column extents are requested.
        @param row: back-filled with the first table row associated with the cell with child index.
        @param col: back-filled with the first table column associated with the cell with child index.
        @param row_extents: back-filled with the number of table rows across which child i extends.
        @param col_extents: back-filled with the number of table columns across which child i extends.
        @param is_selected: a boolean which is back-filled with #TRUE if the child at index i corresponds to a selected table cell, #FALSE otherwise.
        @type index: int
        @type row: int
        @type col: int
        @type row_extents: int
        @type col_extents: int
        @type is_selected: bool
        @returns: #TRUE if the index is associated with a valid table cell, #FALSE if the index does not correspond to a cell.  If #FALSE is returned, the values of the out parameters are undefined.
        @rtype: bool
        """
        return object
    
    def get_row_description(self, row=None):
        """        Gets a text description of a particular table row.  This differs from
        #atspi_table_get_row_header, which returns an #AtspiAccessible.
        @param row: the specified table row, zero-indexed.
        @type row: int
        @returns: a UTF-8 string describing the specified table row, if available.
        @rtype: str
        """
        return object
    
    def get_row_extent_at(self, row=None, column=None):
        """        Gets the number of rows spanned by the table cell at the specific row
        and column. (some tables can have cells which span multiple rows
        and/or columns).
        @param row: the specified table row, zero-indexed.
        @param column: the specified table column, zero-indexed.
        @type row: int
        @type column: int
        @returns: a #gint indicating the number of rows spanned by the specified cell.
        @rtype: int
        """
        return object
    
    def get_row_header(self, row=None):
        """        Gets the header associated with a table row, if available. This differs from
        #atspi_table_get_row_description, which returns a string.
        @param row: the specified table row, zero-indexed.
        @type row: int
        @returns: an #AtspiAccessible representation of the specified
          table row, if available.
        @rtype: Accessible
        """
        return object
    
    def get_selected_columns(self):
        """        Queries a table for a list of indices of columns which are currently
        selected.
        @rtype: None
        """
        return object
    
    def get_selected_rows(self):
        """        Queries a table for a list of indices of rows which are currently selected.
        @rtype: None
        """
        return object
    
    def get_summary(self):
        """        Gets an accessible object which summarizes the contents of an #AtspiTable.
        @returns: an #AtspiAccessible object that serves as the
          table's summary (often a reduced #AtspiTable).
        @rtype: Accessible
        """
        return object
    
    def is_column_selected(self, column=None):
        """        Determines whether specified table column is selected.
        Not all tables support column selection.
        @param column: the zero-indexed column number of the column being queried.
        @type column: int
        @returns: #TRUE if the specified column is currently selected, #FALSE if not.
        @rtype: bool
        """
        return object
    
    def is_row_selected(self, row=None):
        """        Determines whether a table row is selected.  Not all tables support
        row selection.
        @param row: the zero-indexed row number of the row being queried.
        @type row: int
        @returns: #TRUE if the specified row is currently selected, #FALSE if not.
        @rtype: bool
        """
        return object
    
    def is_selected(self, row=None, column=None):
        """        Determines whether the cell at a specific row and column is selected.
        @param row: the zero-indexed row of the cell being queried.
        @param column: the zero-indexed column of the cell being queried.
        @type row: int
        @type column: int
        @returns: #TRUE if the specified cell is currently selected, #FALSE if not.
        @rtype: bool
        """
        return object
    
    def remove_column_selection(self, column=None):
        """        De-selects the specified column, removing it from the current column
        selection.
        Not all tables support column selection.
        @param column: the zero-indexed column number of the column being de-selected.
        @type column: int
        @returns: #TRUE if the specified column was successfully de-selected, #FALSE if not.
        @rtype: bool
        """
        return object
    
    def remove_row_selection(self, row=None):
        """        De-selects the specified row, removing it from the current row selection.
        Not all tables support row selection.
        @param row: the zero-indexed number of the row being de-selected.
        @type row: int
        @returns: #TRUE if the specified row was successfully de-selected, #FALSE if not.
        @rtype: bool
        """
        return object


class TableCell():
    """"""
    
    def get_column_header_cells(self):
        """        Returns the column headers as an array of cell accessibles.
        @rtype: None
        """
        return object
    
    def get_column_index(self):
        """        
        @returns: 
        @rtype: int
        """
        return object
    
    def get_column_span(self):
        """        Returns the number of columns occupied by this cell accessible.
        @returns: a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
        @rtype: int
        """
        return object
    
    def get_position(self, row=None, column=None):
        """        Retrieves the tabular position of this cell.
        @param row: the row of the given cell.
        @param column: the column of the given cell.
        @type row: int
        @type column: int
        @returns: TRUE if successful, FALSE otherwise.
        @rtype: int
        """
        return object
    
    def get_row_column_span(self, row=None, column=None, row_span=None, column_span=None):
        """        Gets the row and column indexes and extents of this cell accessible.
        @param row: the row index of the given cell.
        @param column: the column index of the given cell.
        @param row_span: the number of rows occupied by this cell.
        @param column_span: the number of columns occupied by this cell.
        @type row: int
        @type column: int
        @type row_span: int
        @type column_span: int
        @returns: 
        @rtype: None
        """
        return object
    
    def get_row_header_cells(self):
        """        Returns the row headers as an array of cell accessibles.
        @rtype: None
        """
        return object
    
    def get_row_span(self):
        """        Returns the number of rows occupied by this cell accessible.
        @returns: a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
        @rtype: int
        """
        return object
    
    def get_table(self):
        """        Returns a reference to the accessible of the containing table.
        @returns: the AtspiAccessible for the containing table.
        @rtype: Accessible
        """
        return object


class Text():
    """"""
    
    def add_selection(self, start_offset=None, end_offset=None):
        """        Selects some text (adds a text selection) in an #AtspiText object.
        @param start_offset: the starting offset of the desired new selection.
        @param end_offset: the offset of the first character after the new selection.
        @type start_offset: int
        @type end_offset: int
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def get_attribute_run(self, offset=None, include_defaults=None, start_offset=None, end_offset=None):
        """        Gets a set of attributes applied to a range of text from an #AtspiText object, optionally
        including its 'default' attributes.
        @param offset: a #gint indicating the offset from which the attribute        search is based.
        @param include_defaults: a #bool that, when set as #FALSE, indicates the call should only return those attributes which are explicitly set on the current attribute run, omitting any attributes which are inherited from the default values.
        @param start_offset: a #gint pointer indicating the start of the desired text                range.
        @param end_offset: a #gint pointer indicating the first character past the desired              range.
        @type offset: int
        @type include_defaults: bool
        @type start_offset: int
        @type end_offset: int
        @returns: a #GHashTable with attributes
          defined at the indicated offset, optionally including the 'default' ones.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_attribute_value(self, offset=None, attribute_name=None):
        """        Gets the value of a named attribute at a given offset.
        @param offset: The character offset at which to query the attribute.
        @param attribute_name: The attribute to query.
        @type offset: int
        @type attribute_name: str
        @returns: the value of a given attribute at the given offset, or %NULL if not present.
        @rtype: str
        """
        return object
    
    def get_attributes(self, offset=None, start_offset=None, end_offset=None):
        """        Gets the attributes applied to a range of text from an #AtspiText
        object. The text attributes correspond to CSS attributes
        where possible.
        <em>DEPRECATED</em>
        @param offset: a #gint indicating the offset from which the attribute        search is based.
        @param start_offset: a #gint pointer indicating the start of the desired text                range.
        @param end_offset: a #gint pointer indicating the first character past the desired              range.
        @type offset: int
        @type start_offset: int
        @type end_offset: int
        @returns: a #GHashTable describing the attributes at the given character offset.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_bounded_ranges(self, x=None, y=None, width=None, height=None, type=None, clipTypeX=None, clipTypeY=None):
        """        Gets the ranges of text from an #AtspiText object which lie within the
                 bounds defined by (@x, @y) and (@x+@width, @y+@height).
        @param x: the 'starting' x coordinate of the bounding box.
        @param y: the 'starting' y coordinate of the bounding box.
        @param width: the x extent of the bounding box.
        @param height: the y extent of the bounding box.
        @param type: an #AccessibleCoordType indicating the coordinate system to use        for the returned values.
        @param clipTypeX: an #AtspiTextClipType indicating how to treat characters that        intersect the bounding box's x extents.
        @param clipTypeY: an #AtspiTextClipType indicating how to treat characters that        intersect the bounding box's y extents.
        @type x: int
        @type y: int
        @type width: int
        @type height: int
        @type type: CoordType
        @type clipTypeX: TextClipType
        @type clipTypeY: TextClipType
        @rtype: None
        """
        return object
    
    def get_caret_offset(self):
        """        Gets the current offset of the text caret in an #AtspiText object.
        @returns: a #gint indicating the current position of the text caret.
        @rtype: int
        """
        return object
    
    def get_character_at_offset(self, offset=None):
        """        Gets the character at a given offset for an #AtspiText object.
        @param offset: a #gint indicating the text offset where the desired          character is located.
        @type offset: int
        @returns: a #guint  representing the
        UCS-4 unicode code point of the given character, or
        0xFFFFFFFF if the character in question cannot be represented
        in the UCS-4 encoding.
        @rtype: int
        """
        return object
    
    def get_character_count(self):
        """        Gets the character count of an #AccessibleText object.
        @returns: a #gint indicating the total number of
              characters in the #AccessibleText object.
        @rtype: int
        """
        return object
    
    def get_character_extents(self, offset=None, type=None):
        """        Gets a bounding box containing the glyph representing
               the character at a particular text offset.
        @param offset: a #gint indicating the offset of the text character for        whom boundary information is requested.
        @param type: an #AccessibleCoordType indicating the coordinate system to use        for the returned values.
        @type offset: int
        @type type: CoordType
        @returns: An #AtspiRect specifying the position and size of the character.
        @rtype: Rect
        """
        return object
    
    def get_default_attributes(self):
        """        Gets the default attributes applied to an #AtspiText
        object. The text attributes correspond to CSS attributes
        where possible. The combination of this attribute set and
        the attributes reported by #atspi_text_get_attributes
        describes the entire set of text attributes over a range.
        @returns: a #GHashTable
          containing the default attributes applied to a text object,
          (exclusive of explicitly-set attributes), encoded as UTF-8.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_n_selections(self):
        """        Gets the number of active non-contiguous selections for an
                 #AtspiText object.
        @returns: a #gint indicating the current
          number of non-contiguous text selections active
          within an #AtspiText object.
        @rtype: int
        """
        return object
    
    def get_offset_at_point(self, x=None, y=None, type=None):
        """        Gets the character offset into the text at a given point.
        @param x: the x coordinate of the point to be queried.
        @param y: the y coordinate of the point to be queried.
        @param type: an #AtspiCoordType indicating the coordinate system in which       the values should be returned.
        @type x: int
        @type y: int
        @type type: CoordType
        @returns: the offset (as a #gint) at the point (@x, @y)
       in the specified coordinate system.
        @rtype: int
        """
        return object
    
    def get_range_extents(self, start_offset=None, end_offset=None, type=None):
        """        Gets the bounding box for text within a range in an  #AtspiText object.
        @param start_offset: a #gint indicating the offset of the first text character for        whom boundary information is requested.
        @param end_offset: a #gint indicating the offset of the text character        after the last character for whom boundary information is requested.
        @param type: an #AtspiCoordType indicating the coordinate system to use        for the returned values.
        @type start_offset: int
        @type end_offset: int
        @type type: CoordType
        @returns: An #AtspiRect giving the position and size of the specified range
          of text.
        @rtype: Rect
        """
        return object
    
    def get_selection(self, selection_num=None):
        """        Gets the bounds of the @selection_num-th active text selection for an
                #AtspiText object.
        @param selection_num: a #gint indicating which selection to query.
        @type selection_num: int
        @returns: 
        @rtype: Range
        """
        return object
    
    def get_string_at_offset(self, offset=None, granularity=None):
        """        Gets a portion of the text exposed through an #AtspiText according to a given @offset
        and a specific @granularity, along with the start and end offsets defining the
        boundaries of such a portion of text.
        
        If @granularity is ATSPI_TEXT_GRANULARITY_CHAR the character at the
        offset is returned.
        
        If @granularity is ATSPI_TEXT_GRANULARITY_WORD the returned string
        is from the word start at or before the offset to the word start after
        the offset.
        
        The returned string will contain the word at the offset if the offset
        is inside a word and will contain the word before the offset if the
        offset is not inside a word.
        
        If @granularity is ATSPI_TEXT_GRANULARITY_SENTENCE the returned string
        is from the sentence start at or before the offset to the sentence
        start after the offset.
        
        The returned string will contain the sentence at the offset if the offset
        is inside a sentence and will contain the sentence before the offset
        if the offset is not inside a sentence.
        
        If @granularity is ATSPI_TEXT_GRANULARITY_LINE the returned string
        is from the line start at or before the offset to the line
        start after the offset.
        
        If @granularity is ATSPI_TEXT_GRANULARITY_PARAGRAPH the returned string
        is from the start of the paragraph at or before the offset to the start
        of the following paragraph after the offset.
        @param offset: position
        @param granularity: An #AtspiTextGranularity
        @type offset: int
        @type granularity: TextGranularity
        @returns: a newly allocated string containing the text at the @offset bounded
   by the specified @granularity. Use g_free() to free the returned string.
   Returns %NULL if the offset is invalid or no implementation is available.
        @rtype: TextRange
        """
        return object
    
    def get_text(self, start_offset=None, end_offset=None):
        """        Gets a range of text from an #AtspiText object.  The number of bytes
                 in the returned string may exceed either end_offset or start_offset, since
                 UTF-8 is a variable-width encoding.
        @param start_offset: a #gint indicating the start of the desired text range.
        @param end_offset: a #gint indicating the first character past the desired range.
        @type start_offset: int
        @type end_offset: int
        @returns: a text string containing characters from @start_offset
          to @end_offset-1, inclusive, encoded as UTF-8.
        @rtype: str
        """
        return object
    
    def get_text_after_offset(self, offset=None, type=None):
        """        Gets delimited text from an #AtspiText object which follows a given
                 text offset.
        @param offset: a #gint indicating the offset from which the delimiter        search is based.
        @param type: an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
        @type offset: int
        @type type: TextBoundaryType
        @returns: an #AtspiTextRange containing a UTF-8 string representing the
          delimited text, both of whose delimiting boundaries are after or
          inclusive of the current offset, or an empty string if no such
          text exists.
        @rtype: TextRange
        """
        return object
    
    def get_text_at_offset(self, offset=None, type=None):
        """        Gets delimited text from an #AtspiText object which includes a given
                 text offset.
        @param offset: a #gint indicating the offset from which the delimiter        search is based.
        @param type: an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
        @type offset: int
        @type type: TextBoundaryType
        @returns: an #AtspiTextRange containing a UTF-8 string representing the
          delimited text, whose delimiting boundaries bracket the
          current offset, or an empty string if no such text exists.
        @rtype: TextRange
        """
        return object
    
    def get_text_attribute_value(self, offset=None, attribute_name=None):
        """        Gets the value of a named attribute at a given offset.
        @param offset: The character offset at which to query the attribute.
        @param attribute_name: The attribute to query.
        @type offset: int
        @type attribute_name: str
        @returns: the value of a given attribute at the given offset, or %NULL if not present.
        @rtype: str
        """
        return object
    
    def get_text_attributes(self, offset=None, start_offset=None, end_offset=None):
        """        Gets the attributes applied to a range of text from an #AtspiText
        object. The text attributes correspond to CSS attributes
        where possible.
        <em>DEPRECATED</em>
        @param offset: a #gint indicating the offset from which the attribute        search is based.
        @param start_offset: a #gint pointer indicating the start of the desired text                range.
        @param end_offset: a #gint pointer indicating the first character past the desired              range.
        @type offset: int
        @type start_offset: int
        @type end_offset: int
        @returns: a #GHashTable describing the attributes at the given character offset.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_text_before_offset(self, offset=None, type=None):
        """        Gets delimited text from an #AtspiText object which precedes a given
                 text offset.
        @param offset: a #gint indicating the offset from which the delimiter        search is based.
        @param type: an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
        @type offset: int
        @type type: TextBoundaryType
        @returns: an #AtspiTextRange containing a UTF-8 string representing the
          delimited text, both of whose delimiting boundaries are before the
          current offset, or an empty string if no such text exists.
        @rtype: TextRange
        """
        return object
    
    def remove_selection(self, selection_num=None):
        """        De-selects a text selection.
        @param selection_num: a #gint indicating which text selection to remove.
        @type selection_num: int
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_caret_offset(self, new_offset=None):
        """        Moves the text caret to a given position.
        @param new_offset: the offset to which the text caret is to be moved.
        @type new_offset: int
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object
    
    def set_selection(self, selection_num=None, start_offset=None, end_offset=None):
        """        Changes the bounds of an existing #AtspiText text selection.
        @param selection_num: a zero-offset index indicating which text selection to modify.
        @param start_offset: a #gint indicating the new starting offset for the selection.
        @param end_offset: a #gint indicating the desired new offset of the first character             after the selection.
        @type selection_num: int
        @type start_offset: int
        @type end_offset: int
        @returns: #TRUE if successful, #FALSE otherwise.
        @rtype: bool
        """
        return object


class TextRange():
    """"""

    @property
    def start_offset(self):
        return object

    @property
    def end_offset(self):
        return object

    @property
    def content(self):
        return object


class Value():
    """"""
    
    def get_current_value(self):
        """        Gets the current value for an #AtspiValue.
        @returns: the current value for this object.
        @rtype: float
        """
        return object
    
    def get_maximum_value(self):
        """        Gets the maximum allowed value for an #AtspiValue.
        @returns: the maximum allowed value for this object.
        @rtype: float
        """
        return object
    
    def get_minimum_increment(self):
        """        Gets the minimum increment by which an #AtspiValue can be adjusted.
        @returns: the minimum increment by which the value may be changed, or zero if the minimum increment cannot be determined.
        @rtype: float
        """
        return object
    
    def get_minimum_value(self):
        """        Gets the minimum allowed value for an #AtspiValue.
        @returns: the minimum allowed value for this object.
        @rtype: float
        """
        return object
    
    def set_current_value(self, new_value=None):
        """        Sets the current value of an #AtspiValue.
        @param new_value: a #gdouble value which is the desired new value of the object.
        @type new_value: float
        @returns: #TRUE if the value could be assigned the specified value,
          #FALSE otherwise.
        @rtype: bool
        """
        return object


class Accessible(Object, Action, Collection, Component, Document, EditableText, Hypertext, Image, Selection, Table, TableCell, Text, Value):
    """"""
    
    def clear_cache(self):
        """        Clears the cached information for the given accessible and all of its
        descendants.
        @returns: 
        @rtype: None
        """
        return object
    
    def get_action(self):
        """        Gets the #AtspiAction interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiAction interface
          instance, or NULL if @obj does not implement #AtspiAction.
        @rtype: Action
        """
        return object
    
    def get_action_iface(self):
        """        Gets the #AtspiAction interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiAction interface
          instance, or NULL if @obj does not implement #AtspiAction.
        @rtype: Action
        """
        return object
    
    def get_application(self):
        """        Gets the containing #AtspiApplication for an object.
        @returns: the containing #AtspiApplication instance for
          this object.
        @rtype: Accessible
        """
        return object
    
    def get_atspi_version(self):
        """        Gets the AT-SPI IPC specification version supported by the application
        pointed to by the #AtspiAccessible object.
        Only works on application root objects.
        @returns: a UTF-8 string indicating the AT-SPI version for the #AtspiAccessible object or NULL on exception.
        @rtype: str
        """
        return object
    
    def get_attributes(self):
        """        Gets the #AttributeSet representing any assigned
        name-value pair attributes or annotations for this object.
        For typographic, textual, or textually-semantic attributes, see
        atspi_text_get_attributes instead.
        @returns: The name-value-pair attributes assigned to this object.
        @rtype: GLib.HashTable
        """
        return object
    
    def get_attributes_as_array(self):
        """        Gets a #GArray representing any assigned
        name-value pair attributes or annotations for this object.
        For typographic, textual, or textually-semantic attributes, see
        atspi_text_get_attributes_as_array instead.
        @rtype: None
        """
        return object
    
    def get_child_at_index(self, child_index=None):
        """        Gets the #AtspiAccessible child of an #AtspiAccessible object at a given index.
        @param child_index: a #long indicating which child is specified.
        @type child_index: int
        @returns: a pointer to the #AtspiAccessible child object at index @child_index or NULL on exception.
        @rtype: Accessible
        """
        return object
    
    def get_child_count(self):
        """        Gets the number of children contained by an #AtspiAccessible object.
        @returns: a #long indicating the number of #AtspiAccessible children
          contained by an #AtspiAccessible object or -1 on exception.
        @rtype: int
        """
        return object
    
    def get_collection(self):
        """        Gets the #AtspiCollection interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiCollection interface
          instance, or NULL if @obj does not implement #AtspiCollection.
        @rtype: Collection
        """
        return object
    
    def get_collection_iface(self):
        """        Gets the #AtspiCollection interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiCollection interface
          instance, or NULL if @obj does not implement #AtspiCollection.
        @rtype: Collection
        """
        return object
    
    def get_component(self):
        """        Gets the #AtspiComponent interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiComponent interface
          instance, or NULL if @obj does not implement #AtspiComponent.
        @rtype: Component
        """
        return object
    
    def get_component_iface(self):
        """        Gets the #AtspiComponent interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiComponent interface
          instance, or NULL if @obj does not implement #AtspiComponent.
        @rtype: Component
        """
        return object
    
    def get_description(self):
        """        Gets the description of an #AtspiAccessible object.
        @returns: a UTF-8 string describing the #AtspiAccessible object or NULL on exception.
        @rtype: str
        """
        return object
    
    def get_document(self):
        """        Gets the #AtspiDocument interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiDocument interface
          instance, or NULL if @obj does not implement #AtspiDocument.
        @rtype: Document
        """
        return object
    
    def get_document_iface(self):
        """        Gets the #AtspiDocument interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiDocument interface
          instance, or NULL if @obj does not implement #AtspiDocument.
        @rtype: Document
        """
        return object
    
    def get_editable_text(self):
        """        Gets the #AtspiEditableText interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiEditableText interface
          instance, or NULL if @obj does not implement #AtspiEditableText.
        @rtype: EditableText
        """
        return object
    
    def get_editable_text_iface(self):
        """        Gets the #AtspiEditableText interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiEditableText interface
          instance, or NULL if @obj does not implement #AtspiEditableText.
        @rtype: EditableText
        """
        return object
    
    def get_hyperlink(self):
        """        Gets the #AtspiHyperlink interface for an #AtspiAccessible.
        @returns: the #AtspiHyperlink object associated with
          the given #AtspiAccessible, or NULL if not supported.
        @rtype: Hyperlink
        """
        return object
    
    def get_hypertext(self):
        """        Gets the #AtspiHypertext interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiHypertext interface
          instance, or NULL if @obj does not implement #AtspiHypertext.
        @rtype: Hypertext
        """
        return object
    
    def get_hypertext_iface(self):
        """        Gets the #AtspiHypertext interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiHypertext interface
          instance, or NULL if @obj does not implement #AtspiHypertext.
        @rtype: Hypertext
        """
        return object
    
    def get_id(self):
        """        Gets the application id for a #AtspiAccessible object.
        Only works on application root objects.
        @returns: a positive #gint indicating the id for the #AtspiAccessible object or -1 on exception.
        @rtype: int
        """
        return object
    
    def get_image(self):
        """        Gets the #AtspiImage interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiImage interface instance, or
          NULL if @obj does not implement #AtspiImage.
        @rtype: Image
        """
        return object
    
    def get_image_iface(self):
        """        Gets the #AtspiImage interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiImage interface instance, or
          NULL if @obj does not implement #AtspiImage.
        @rtype: Image
        """
        return object
    
    def get_index_in_parent(self):
        """        Gets the index of an #AtspiAccessible object within its parent's
        #AtspiAccessible children list.
        @returns: a #glong indicating the index of the #AtspiAccessible object
          in its parent,
          or -1 if @obj has no containing parent or on exception.
        @rtype: int
        """
        return object
    
    def get_interfaces(self):
        """        A set of pointers to all interfaces supported by an #AtspiAccessible.
        @rtype: None
        """
        return object
    
    def get_localized_role_name(self):
        """        Gets a UTF-8 string corresponding to the name of the role played by an
        object, translated to the current locale.
        This method will return useful values for roles that fall outside the
        enumeration used in atspi_accessible_getRole ().
        @returns: a localized, UTF-8 string specifying the type of UI role played by an #AtspiAccessible object.
        @rtype: str
        """
        return object
    
    def get_name(self):
        """        Gets the name of an #AtspiAccessible object.
        @returns: a UTF-8 string indicating the name of the #AtspiAccessible object or NULL on exception.
        @rtype: str
        """
        return object
    
    def get_object_locale(self):
        """        
        @returns: 
        @rtype: str
        """
        return object
    
    def get_parent(self):
        """        Gets an #AtspiAccessible object's parent container.
        @returns: a pointer to the
          #AtspiAccessible object which contains the given
          #AtspiAccessible instance, or NULL if the @obj has no
          parent container.
        @rtype: Accessible
        """
        return object
    
    def get_process_id(self):
        """        Returns the process id associated with the given accessible.  Mainly
        added for debugging; it is a shortcut to explicitly querying the
        accessible's app->bus_name and then calling GetConnectionUnixProcessID.
        @returns: The process ID or undetermined value if @error is set.
        @rtype: int
        """
        return object
    
    def get_relation_set(self):
        """        Gets the set of #AtspiRelation objects which describes this #AtspiAccessible object's
        relationships with other #AtspiAccessible objects.
        @rtype: None
        """
        return object
    
    def get_role(self):
        """        Gets the UI role played by an #AtspiAccessible object.
        This role's name can be obtained via atspi_accessible_get_role_name ().
        @returns: the #AtspiRole of an #AtspiAccessible object.
        @rtype: Role
        """
        return object
    
    def get_role_name(self):
        """        Gets a UTF-8 string corresponding to the name of the role played by an object.
        This method will return useful values for roles that fall outside the
        enumeration used in atspi_accessible_get_role ().
        @returns: a UTF-8 string specifying the type of UI role played by an #AtspiAccessible object.
        @rtype: str
        """
        return object
    
    def get_selection(self):
        """        Gets the #AtspiSelection interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiSelection interface
          instance, or NULL if @obj does not implement #AtspiSelection.
        @rtype: Selection
        """
        return object
    
    def get_selection_iface(self):
        """        Gets the #AtspiSelection interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiSelection interface
          instance, or NULL if @obj does not implement #AtspiSelection.
        @rtype: Selection
        """
        return object
    
    def get_state_set(self):
        """        Gets the states currently held by an object.
        @returns: a pointer to an #AtspiStateSet representing an object's current state set.
        @rtype: StateSet
        """
        return object
    
    def get_table(self):
        """        Gets the #AtspiTable interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiTable interface instance, or
          NULL if @obj does not implement #AtspiTable.
        @rtype: Table
        """
        return object
    
    def get_table_cell(self):
        """        Gets the #AtspiTableCell interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiTableCell interface instance,
          or NULL if @obj does not implement #AtspiTable.
        @rtype: TableCell
        """
        return object
    
    def get_table_iface(self):
        """        Gets the #AtspiTable interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiTable interface instance, or
          NULL if @obj does not implement #AtspiTable.
        @rtype: Table
        """
        return object
    
    def get_text(self):
        """        Gets the #AtspiTable interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiText interface instance, or
          NULL if @obj does not implement #AtspiText.
        @rtype: Text
        """
        return object
    
    def get_text_iface(self):
        """        Gets the #AtspiTable interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiText interface instance, or
          NULL if @obj does not implement #AtspiText.
        @rtype: Text
        """
        return object
    
    def get_toolkit_name(self):
        """        Gets the toolkit name for an #AtspiAccessible object.
        Only works on application root objects.
        @returns: a UTF-8 string indicating the toolkit name for the #AtspiAccessible object or NULL on exception.
        @rtype: str
        """
        return object
    
    def get_toolkit_version(self):
        """        Gets the toolkit version for an #AtspiAccessible object.
        Only works on application root objects.
        @returns: a UTF-8 string indicating the toolkit version for the #AtspiAccessible object or NULL on exception.
        @rtype: str
        """
        return object
    
    def get_value(self):
        """        Gets the #AtspiTable interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiValue interface instance, or
          NULL if @obj does not implement #AtspiValue.
        @rtype: Value
        """
        return object
    
    def get_value_iface(self):
        """        Gets the #AtspiTable interface for an #AtspiAccessible.
        @returns: a pointer to an #AtspiValue interface instance, or
          NULL if @obj does not implement #AtspiValue.
        @rtype: Value
        """
        return object
    
    def set_cache_mask(self, mask=None):
        """        Sets the type of data to cache for accessibles.
        If this is not set for an application or is reset to ATSPI_CACHE_UNDEFINED,
        then the desktop's cache flag will be used.
        If the desktop's cache flag is also undefined, then all possible data will
        be cached.
        This function is intended to work around bugs in toolkits where the proper
        events are not raised / to aid in testing for such bugs.
        @param mask: An #AtspiCache specifying a bit mask of the types of data to cache.
        @type mask: Cache
        @returns: 
        @rtype: None
        """
        return object

    @property
    def parent(self):
        return object

    @property
    def accessible_parent(self):
        return object

    @property
    def children(self):
        return object

    @property
    def role(self):
        return object

    @property
    def interfaces(self):
        return object

    @property
    def name(self):
        return object

    @property
    def description(self):
        return object

    @property
    def states(self):
        return object

    @property
    def attributes(self):
        return object

    @property
    def cached_properties(self):
        return object

    @property
    def priv(self):
        return object


class Hyperlink(Object):
    """"""
    
    def get_end_index(self):
        """        Gets the ending character offset of the text range associated with
              an #AtspiHyperlink, in its originating #AtspiHypertext.
        @returns: 
        @rtype: int
        """
        return object
    
    def get_index_range(self):
        """        Gets the starting and ending character offsets of the text range
        associated with an #AtspiHyperlink, in its originating #AtspiHypertext.
        @returns: 
        @rtype: Range
        """
        return object
    
    def get_n_anchors(self):
        """        Gets the total number of anchors which an #AtspiHyperlink implementor has.
        Though typical hyperlinks have only one anchor, client-side image maps and
        other hypertext objects may potentially activate or refer to multiple
        URIs.  For each anchor there is a corresponding URI and object.
        
        see: #atspi_hyperlink_get_uri and #atspi_hyperlink_get_object.
        @returns: a #gint indicating the number of anchors in this hyperlink.
        @rtype: int
        """
        return object
    
    def get_object(self, i=None):
        """        Gets the object associated with a particular hyperlink anchor, as an
        #AtspiAccessible.
        @param i: a (zero-index) #gint indicating which hyperlink anchor to query.
        @type i: int
        @returns: an #AtspiAccessible that represents the object
        associated with the @ith anchor of the specified #AtspiHyperlink.
        @rtype: Accessible
        """
        return object
    
    def get_start_index(self):
        """        Gets the starting character offset of the text range associated with
              an #AtspiHyperlink, in its originating #AtspiHypertext.
        @returns: 
        @rtype: int
        """
        return object
    
    def get_uri(self, i=None):
        """        Gets the URI associated with a particular hyperlink anchor.
        @param i: a (zero-index) integer indicating which hyperlink anchor to query.
        @type i: int
        @returns: a UTF-8 string giving the URI of the @ith hyperlink anchor.
        @rtype: str
        """
        return object
    
    def is_valid(self):
        """        Tells whether an #AtspiHyperlink object is still valid with respect to its
                 originating hypertext object.
        @returns: #TRUE if the specified #AtspiHyperlink is still valid with respect
          to its originating #AtspiHypertext object, #FALSE otherwise.
        @rtype: bool
        """
        return object

    @property
    def parent(self):
        return object
